@seanyao/roll 2026.529.5 → 2026.601.2

package/lib/roll-onboard-render.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""
+US-ONBOARD-017: render the three Phase 2 analysis sections of onboard-plan.yaml
+(domain_model / tech_analysis / test_assessment, produced by US-ONBOARD-016)
+into human-readable markdown inside the onboarded project, and surface the
+BACKLOG / FIX seed candidates for bash to gate behind a [Y/n] confirm.
+
+This script NEVER writes to BACKLOG and NEVER touches the offboard changeset.
+Those mutations stay in bash (bin/roll `_init_apply`) so the confirm gate and
+the rollback registry remain the single source of truth. This script only:
+
+  1. Renders three markdown files into <project_dir>/.roll/ , deterministically
+     (same plan.yaml -> byte-identical markdown; no wall-clock timestamps or
+     random IDs are embedded in the body).
+  2. Emits a machine-parseable manifest on stdout describing exactly what it
+     wrote and what could be seeded, in a pipe-delimited line format that bash
+     parses with `IFS='|' read` (no jq dependency):
+
+        FILE|.roll/domain/context-map.md
+        FILE|.roll/tech-analysis.md
+        FILE|.roll/test-assessment.md
+        SEED|US-SEED-001|add a macOS CI runner
+        FIX|FIX-SEED-001|no automated test run on macOS bash 3.2
+
+     `FILE|` lines are project-relative paths bash records into the changeset's
+     `files_created` (so `roll offboard` removes them). `SEED|` / `FIX|` lines
+     are candidates; bash prints a preview and only writes them on explicit
+     confirmation.
+
+Atomicity (per peer review): all three files are staged to temp paths inside
+the project dir and atomically renamed into place. If rendering any file fails,
+nothing is left half-written and no manifest is emitted, so bash records no
+changeset entries for files that do not exist.
+
+Usage:
+    python3 roll-onboard-render.py <plan.yaml> <project_dir>
+
+Exit codes:
+    0   rendered OK (manifest on stdout)
+    1   plan unreadable / not a mapping / render failure
+    2   plan has none of the three sections (nothing to render; no-op)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+try:
+    import yaml  # PyYAML
+except ImportError:
+    print(
+        "[onboard-render] PyYAML not installed. Install with: pip install pyyaml\n"
+        "[onboard-render] PyYAML 未安装，请运行: pip install pyyaml",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+# Project-relative output paths (the AC fixes these three exact locations).
+CONTEXT_MAP_REL = ".roll/domain/context-map.md"
+TECH_ANALYSIS_REL = ".roll/tech-analysis.md"
+TEST_ASSESSMENT_REL = ".roll/test-assessment.md"
+
+# HIGH-severity risks are the only ones eligible to seed as FIX candidates.
+HIGH_SEVERITY = "HIGH"
+
+
+def _as_list(value) -> list:
+    """Coerce a possibly-missing field into a list, preserving order.
+
+    A scalar becomes a one-item list; None/missing becomes []. Never sorts —
+    determinism comes from honouring the author's order in the plan.
+    """
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def _term_text(term) -> str:
+    """Render a ubiquitous_language entry, which may be a bare string or a
+    {term, definition} mapping (the schema allows both)."""
+    if isinstance(term, dict):
+        name = str(term.get("term", "")).strip()
+        definition = str(term.get("definition", "")).strip()
+        if name and definition:
+            return f"{name} — {definition}"
+        return name or definition
+    return str(term).strip()
+
+
+def _claim_text(claim) -> tuple[str, str]:
+    """Return (text, evidence) for a test_assessment claim.
+
+    Claims are validated upstream as mappings carrying an `evidence` tag, but we
+    stay defensive so a malformed-but-parseable plan still renders rather than
+    crashing.
+    """
+    if isinstance(claim, dict):
+        text = str(claim.get("claim", "")).strip()
+        evidence = str(claim.get("evidence", "")).strip()
+        return text, evidence
+    return str(claim).strip(), ""
+
+
+def render_context_map(domain_model: dict | None) -> str:
+    """Render .roll/domain/context-map.md from domain_model. Deterministic."""
+    lines: list[str] = ["# Domain Context Map", ""]
+    lines.append(
+        "> Generated by `roll init --apply` from `.roll/onboard-plan.yaml` "
+        "(US-ONBOARD-016/017). Regenerate by re-running onboard."
+    )
+    lines.append("")
+    contexts = _as_list((domain_model or {}).get("bounded_contexts"))
+    if not contexts:
+        lines.append("_No bounded contexts were inferred from the codebase._")
+        lines.append("")
+        return "\n".join(lines) + "\n"
+
+    for ctx in contexts:
+        if not isinstance(ctx, dict):
+            continue
+        name = str(ctx.get("name", "")).strip() or "(unnamed context)"
+        lines.append(f"## {name}")
+        lines.append("")
+        aggregates = _as_list(ctx.get("aggregates"))
+        lines.append("**Aggregates**")
+        lines.append("")
+        if aggregates:
+            for agg in aggregates:
+                lines.append(f"- {str(agg).strip()}")
+        else:
+            lines.append("- _none identified_")
+        lines.append("")
+        language = _as_list(ctx.get("ubiquitous_language"))
+        lines.append("**Ubiquitous language**")
+        lines.append("")
+        if language:
+            for term in language:
+                text = _term_text(term)
+                if text:
+                    lines.append(f"- {text}")
+        else:
+            lines.append("- _none identified_")
+        lines.append("")
+    return "\n".join(lines) + "\n"
+
+
+def render_tech_analysis(tech: dict | None) -> str:
+    """Render .roll/tech-analysis.md from tech_analysis. Deterministic."""
+    lines: list[str] = ["# Technical Analysis", ""]
+    lines.append(
+        "> Generated by `roll init --apply` from `.roll/onboard-plan.yaml` "
+        "(US-ONBOARD-016/017). Regenerate by re-running onboard."
+    )
+    lines.append("")
+    tech = tech or {}
+
+    def _bullet_section(title: str, key: str) -> None:
+        lines.append(f"## {title}")
+        lines.append("")
+        items = _as_list(tech.get(key))
+        if items:
+            for item in items:
+                lines.append(f"- {str(item).strip()}")
+        else:
+            lines.append("- _none detected_")
+        lines.append("")
+
+    _bullet_section("Stack", "stack")
+    _bullet_section("Dependencies", "dependencies")
+    _bullet_section("Architecture notes", "architecture_notes")
+
+    lines.append("## Risks")
+    lines.append("")
+    risks = _as_list(tech.get("risks"))
+    if not risks:
+        lines.append("- _none detected_")
+        lines.append("")
+        return "\n".join(lines) + "\n"
+
+    for risk in risks:
+        if not isinstance(risk, dict):
+            lines.append(f"- {str(risk).strip()}")
+            continue
+        desc = str(risk.get("description", "")).strip()
+        severity = str(risk.get("severity", "")).strip()
+        evidence = str(risk.get("evidence", "")).strip()
+        tags = []
+        if severity:
+            tags.append(f"severity: {severity}")
+        if evidence:
+            tags.append(f"evidence: {evidence}")
+        suffix = f" ({', '.join(tags)})" if tags else ""
+        lines.append(f"- {desc}{suffix}")
+    lines.append("")
+    return "\n".join(lines) + "\n"
+
+
+def render_test_assessment(test: dict | None) -> str:
+    """Render .roll/test-assessment.md from test_assessment. Deterministic.
+
+    Distinguishes `detected` (a real scan finding) from `inferred` (a judgement)
+    by labelling each bullet, honouring US-ONBOARD-016's evidence contract.
+    """
+    lines: list[str] = ["# Test Coverage Assessment", ""]
+    lines.append(
+        "> Generated by `roll init --apply` from `.roll/onboard-plan.yaml` "
+        "(US-ONBOARD-016/017). Every claim is evidence-tagged: **detected** "
+        "(found by a filesystem scan) or **inferred** (a judgement traceable to "
+        "a detected fact)."
+    )
+    lines.append("")
+    test = test or {}
+
+    def _claims_section(title: str, key: str) -> None:
+        lines.append(f"## {title}")
+        lines.append("")
+        claims = _as_list(test.get(key))
+        if claims:
+            for claim in claims:
+                text, evidence = _claim_text(claim)
+                if not text:
+                    continue
+                if evidence:
+                    lines.append(f"- {text} _(evidence: {evidence})_")
+                else:
+                    lines.append(f"- {text}")
+        else:
+            lines.append("- _none recorded_")
+        lines.append("")
+
+    _claims_section("Current layers", "current_layers")
+    _claims_section("Gaps", "gaps")
+    _claims_section("Recommended actions", "recommended_actions")
+    return "\n".join(lines) + "\n"
+
+
+def collect_seed_candidates(plan: dict) -> tuple[list[str], list[str]]:
+    """Return (story_titles, fix_titles) in plan order.
+
+    Stories come from test_assessment.recommended_actions (each becomes a
+    candidate BACKLOG story). FIX candidates come from tech_analysis.risks whose
+    severity == HIGH. Titles are the human-readable claim/description text;
+    bash assigns the deterministic US-SEED-NNN / FIX-SEED-NNN ids.
+    """
+    stories: list[str] = []
+    test = plan.get("test_assessment") or {}
+    for claim in _as_list(test.get("recommended_actions")):
+        text, _ = _claim_text(claim)
+        if text and text.lower() != "none detected":
+            stories.append(text)
+
+    fixes: list[str] = []
+    tech = plan.get("tech_analysis") or {}
+    for risk in _as_list(tech.get("risks")):
+        if not isinstance(risk, dict):
+            continue
+        if str(risk.get("severity", "")).strip().upper() == HIGH_SEVERITY:
+            desc = str(risk.get("description", "")).strip()
+            if desc:
+                fixes.append(desc)
+    return stories, fixes
+
+
+def _atomic_write(project_dir: Path, rel: str, content: str) -> None:
+    """Write content to <project_dir>/<rel> atomically (temp + os.replace).
+
+    The temp file is created in the same directory as the target so the rename
+    is atomic on the same filesystem.
+    """
+    target = project_dir / rel
+    target.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_name = tempfile.mkstemp(
+        prefix=f".{target.name}.", suffix=".tmp", dir=str(target.parent)
+    )
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        os.replace(tmp_name, str(target))
+    except BaseException:
+        # Clean up the temp file on any failure so we never leak half-writes.
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        raise
+
+
+def _emit(line: str) -> None:
+    sys.stdout.write(line + "\n")
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) < 3:
+        print(
+            "[onboard-render] usage: roll-onboard-render.py <plan.yaml> <project_dir>",
+            file=sys.stderr,
+        )
+        return 1
+
+    plan_path = Path(argv[1])
+    project_dir = Path(argv[2])
+
+    if not plan_path.is_file():
+        print(f"[onboard-render] plan not found: {plan_path}", file=sys.stderr)
+        return 1
+    if not project_dir.is_dir():
+        print(
+            f"[onboard-render] project dir not found: {project_dir}", file=sys.stderr
+        )
+        return 1
+
+    try:
+        with plan_path.open("r", encoding="utf-8") as f:
+            plan = yaml.safe_load(f)
+    except (yaml.YAMLError, OSError) as e:
+        print(f"[onboard-render] failed to parse plan: {e}", file=sys.stderr)
+        return 1
+
+    if not isinstance(plan, dict):
+        print("[onboard-render] plan must be a top-level mapping", file=sys.stderr)
+        return 1
+
+    has_dm = isinstance(plan.get("domain_model"), dict)
+    has_ta = isinstance(plan.get("tech_analysis"), dict)
+    has_test = isinstance(plan.get("test_assessment"), dict)
+    if not (has_dm or has_ta or has_test):
+        # No Phase 2 content at all — nothing to render. Bash treats exit 2 as a
+        # clean no-op (an old plan, or a minimal onboard).
+        return 2
+
+    # Render bodies first (pure, in-memory) so a render bug fails before we
+    # touch the filesystem at all.
+    try:
+        bodies = [
+            (CONTEXT_MAP_REL, render_context_map(plan.get("domain_model"))),
+            (TECH_ANALYSIS_REL, render_tech_analysis(plan.get("tech_analysis"))),
+            (TEST_ASSESSMENT_REL, render_test_assessment(plan.get("test_assessment"))),
+        ]
+    except Exception as e:  # pragma: no cover - defensive
+        print(f"[onboard-render] render failed: {e}", file=sys.stderr)
+        return 1
+
+    # Stage + atomically write all three. If any write fails, roll back the
+    # ones already renamed so we never leave partial state.
+    written: list[str] = []
+    try:
+        for rel, body in bodies:
+            _atomic_write(project_dir, rel, body)
+            written.append(rel)
+    except OSError as e:
+        for rel in written:
+            try:
+                os.unlink(str(project_dir / rel))
+            except OSError:
+                pass
+        print(f"[onboard-render] write failed: {e}", file=sys.stderr)
+        return 1
+
+    stories, fixes = collect_seed_candidates(plan)
+
+    # Emit the manifest only after every file is on disk.
+    for rel, _ in bodies:
+        _emit(f"FILE|{rel}")
+    for i, title in enumerate(stories, start=1):
+        _emit(f"SEED|US-SEED-{i:03d}|{title}")
+    for i, desc in enumerate(fixes, start=1):
+        _emit(f"FIX|FIX-SEED-{i:03d}|{desc}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

package/lib/roll-peer.py

@@ -99,7 +99,7 @@ _FIXTURE_VERDICT = {
     "reason":  "2 rounds · 5 turns · all blocks resolved",
 }
 
-_FIXTURE_ARTIFACT = "~/.roll/.peer-state/logs/20260519_213700_claude_codex.md"
+_FIXTURE_ARTIFACT = ".roll/peer/logs/20260519_213700_claude_codex.md"
 _FIXTURE_NEXT = [
     ("Continue execution",   "claude resumes work on US-AUTH-014"),
     ("Inspect log",          "open the artifact above to replay the transcript"),

package/lib/roll-plan-validate.py

@@ -34,6 +34,38 @@ Schema (v1):
       gitignore_dot_roll: bool
     sync_targets: [str]
     enable_loop: bool
+
+US-ONBOARD-016 — Phase 2 analysis sections (all OPTIONAL, pure-incremental,
+backward compatible; an old plan that omits them still validates). When
+present, each is validated for structure:
+
+    domain_model:
+      bounded_contexts:
+        - name: str
+          aggregates: [str]
+          ubiquitous_language: [str]   # or [{term, definition}]
+    tech_analysis:
+      stack: [str]
+      dependencies: [str]
+      architecture_notes: [str]
+      risks:
+        - description: str
+          severity: LOW | MEDIUM | HIGH   # optional
+          evidence: detected | inferred   # optional
+    test_assessment:
+      current_layers:     [<claim>]
+      gaps:               [<claim>]
+      recommended_actions:[<claim>]
+
+ANTI-HALLUCINATION HARD CONSTRAINT (the heart of US-ONBOARD-016):
+Every test_assessment claim MUST be a mapping carrying an `evidence` key whose
+value is exactly `detected` or `inferred`. A schema validator cannot re-run the
+filesystem scan, so the data contract is the lever: free-floating untagged
+strings (e.g. a hallucinated "needs more E2E tests") are REJECTED. When a scan
+finds nothing the skill must still emit a tagged claim such as
+`{claim: "none detected", evidence: detected}` — never invent filler. A scan
+that ran and returned zero matches is a genuine detection, so "none detected"
+carries `evidence: detected` (not a third enum value).
 """
 
 from __future__ import annotations
@@ -58,6 +90,14 @@ MAX_AGE_HOURS = 24
 VALID_PROJECT_TYPES = {"backend-service", "frontend-only", "fullstack", "cli"}
 VALID_SCOPE_ITEMS = {"backlog", "features", "domain", "briefs"}
 
+# US-ONBOARD-016: anti-hallucination evidence tags. Every test_assessment claim
+# must carry one of these; risks[].evidence (when present) uses the same enum.
+VALID_EVIDENCE = {"detected", "inferred"}
+# test_assessment buckets whose entries are evidence-tagged claims.
+TEST_ASSESSMENT_CLAIM_KEYS = ("current_layers", "gaps", "recommended_actions")
+# Optional severity enum for tech_analysis.risks[].severity.
+VALID_RISK_SEVERITY = {"LOW", "MEDIUM", "HIGH"}
+
 
 def err(msg_en: str, msg_zh: str = "") -> None:
     """Print bilingual error to stderr."""
@@ -162,6 +202,126 @@ def validate_privacy(plan: dict) -> list[str]:
     return errors
 
 
+def validate_domain_model(plan: dict) -> list[str]:
+    """US-ONBOARD-016: validate the optional domain_model section.
+
+    Absent → no errors (pure-incremental). When present it must be a mapping
+    with a bounded_contexts list; each context is a mapping with a name and
+    list-typed aggregates / ubiquitous_language.
+    """
+    errors: list[str] = []
+    if "domain_model" not in plan:
+        return errors
+    dm = plan.get("domain_model")
+    if not isinstance(dm, dict):
+        return ["domain_model must be a mapping"]
+    contexts = dm.get("bounded_contexts")
+    if contexts is None:
+        return ["domain_model.bounded_contexts missing"]
+    if not isinstance(contexts, list):
+        return ["domain_model.bounded_contexts must be a list"]
+    for i, ctx in enumerate(contexts):
+        where = f"domain_model.bounded_contexts[{i}]"
+        if not isinstance(ctx, dict):
+            errors.append(f"{where} must be a mapping")
+            continue
+        if not ctx.get("name"):
+            errors.append(f"{where}.name missing or empty")
+        for list_key in ("aggregates", "ubiquitous_language"):
+            if list_key in ctx and not isinstance(ctx[list_key], list):
+                errors.append(f"{where}.{list_key} must be a list")
+    return errors
+
+
+def _validate_evidence_value(value, where: str) -> list[str]:
+    """Shared check: a value must be exactly one of VALID_EVIDENCE."""
+    if value is None:
+        return [f"{where}.evidence missing (must be one of {sorted(VALID_EVIDENCE)})"]
+    if value not in VALID_EVIDENCE:
+        return [
+            f"{where}.evidence='{value}' invalid "
+            f"(must be one of {sorted(VALID_EVIDENCE)})"
+        ]
+    return []
+
+
+def validate_tech_analysis(plan: dict) -> list[str]:
+    """US-ONBOARD-016: validate the optional tech_analysis section.
+
+    Absent → no errors. When present: stack / dependencies / architecture_notes
+    (if given) must be lists; risks (if given) must be a list of mappings each
+    with a description, an optional severity in VALID_RISK_SEVERITY, and an
+    optional evidence tag in VALID_EVIDENCE.
+    """
+    errors: list[str] = []
+    if "tech_analysis" not in plan:
+        return errors
+    ta = plan.get("tech_analysis")
+    if not isinstance(ta, dict):
+        return ["tech_analysis must be a mapping"]
+    for list_key in ("stack", "dependencies", "architecture_notes"):
+        if list_key in ta and not isinstance(ta[list_key], list):
+            errors.append(f"tech_analysis.{list_key} must be a list")
+    if "risks" in ta:
+        risks = ta["risks"]
+        if not isinstance(risks, list):
+            errors.append("tech_analysis.risks must be a list")
+        else:
+            for i, risk in enumerate(risks):
+                where = f"tech_analysis.risks[{i}]"
+                if not isinstance(risk, dict):
+                    errors.append(f"{where} must be a mapping")
+                    continue
+                if not risk.get("description"):
+                    errors.append(f"{where}.description missing or empty")
+                sev = risk.get("severity")
+                if sev is not None and sev not in VALID_RISK_SEVERITY:
+                    errors.append(
+                        f"{where}.severity='{sev}' invalid "
+                        f"(must be one of {sorted(VALID_RISK_SEVERITY)})"
+                    )
+                if "evidence" in risk:
+                    errors += _validate_evidence_value(risk["evidence"], where)
+    return errors
+
+
+def validate_test_assessment(plan: dict) -> list[str]:
+    """US-ONBOARD-016 anti-hallucination HARD constraint.
+
+    Absent → no errors. When present, every entry in current_layers / gaps /
+    recommended_actions MUST be a mapping carrying an `evidence` tag of exactly
+    `detected` or `inferred`. This is the mechanical lever: untagged free-text
+    claims (hallucinated filler) are rejected. An empty bucket is allowed — that
+    is how "the section ran but had nothing in this dimension" is expressed; the
+    skill represents a zero-result scan as a tagged `{claim: "none detected",
+    evidence: detected}` entry rather than inventing a recommendation.
+    """
+    errors: list[str] = []
+    if "test_assessment" not in plan:
+        return errors
+    ta = plan.get("test_assessment")
+    if not isinstance(ta, dict):
+        return ["test_assessment must be a mapping"]
+    for key in TEST_ASSESSMENT_CLAIM_KEYS:
+        if key not in ta:
+            continue
+        claims = ta[key]
+        if not isinstance(claims, list):
+            errors.append(f"test_assessment.{key} must be a list")
+            continue
+        for i, claim in enumerate(claims):
+            where = f"test_assessment.{key}[{i}]"
+            if not isinstance(claim, dict):
+                errors.append(
+                    f"{where} must be a mapping carrying an 'evidence' tag "
+                    f"(got {type(claim).__name__}); untagged claims are rejected "
+                    f"to block unverifiable filler"
+                )
+                continue
+            errors += _validate_evidence_value(claim.get("evidence"), where)
+    return errors
+
+
 def main(argv: list[str]) -> int:
     if len(argv) < 2:
         err("usage: roll-plan-validate.py <plan.yaml>", "用法: roll-plan-validate.py <plan.yaml>")
@@ -189,6 +349,11 @@ def main(argv: list[str]) -> int:
     schema_errors += validate_project_understanding(plan)
     schema_errors += validate_scope(plan)
     schema_errors += validate_privacy(plan)
+    # US-ONBOARD-016: optional Phase 2 analysis sections (validated only when
+    # present so old plans stay compatible).
+    schema_errors += validate_domain_model(plan)
+    schema_errors += validate_tech_analysis(plan)
+    schema_errors += validate_test_assessment(plan)
 
     freshness_errors, is_stale = validate_freshness(plan)
 

package/lib/roll_git.py

@@ -0,0 +1,41 @@
+"""
+roll_git — shared git helpers for roll CLI scripts.
+
+Standalone entry scripts (roll-home.py, roll-loop-status.py, ...) insert
+_LIB_DIR into sys.path and import these helpers, mirroring the roll_render
+import pattern. Keeps git/subprocess plumbing out of the pure-rendering
+roll_render module and gives slug derivation a single source of truth.
+"""
+
+from __future__ import annotations
+import subprocess
+from typing import Optional
+
+
+def git_remote_url(repo_path: str) -> Optional[str]:
+    """Return the remote URL for a git repo — origin first, then any — or None."""
+    try:
+        url = subprocess.check_output(
+            ["git", "-C", repo_path, "remote", "get-url", "origin"],
+            stderr=subprocess.DEVNULL, text=True,
+        ).strip()
+        if url:
+            return url
+    except Exception:
+        pass
+    # Fallback: first available remote
+    try:
+        remotes = subprocess.check_output(
+            ["git", "-C", repo_path, "remote"],
+            stderr=subprocess.DEVNULL, text=True,
+        ).strip().splitlines()
+        if remotes:
+            url = subprocess.check_output(
+                ["git", "-C", repo_path, "remote", "get-url", remotes[0]],
+                stderr=subprocess.DEVNULL, text=True,
+            ).strip()
+            if url:
+                return url
+    except Exception:
+        pass
+    return None

package/lib/slides/components/README.md

@@ -97,8 +97,14 @@ new class names — the template's CSS is the single source of truth.
 ## Usage
 
 Partials are consumed by `lib/slides-render.py` when a `deck.md` slide declares
-a `layout` field (US-DECK-017). Until then, all partials render the same
-`plain` layout by default.
+a `layout` field. A slide that omits `layout` renders as `plain`.
+
+For the user-facing walkthrough — per-layout `deck.md` examples, rendered
+screenshots, and how `$roll-deck` picks a layout — see the Layouts section of
+the slides guide: [`guide/en/slides.md`](../../../guide/en/slides.md#layouts)
+([中文](../../../guide/zh/slides.md#layouts布局)). Field names in this file,
+that guide, and `skills/roll-deck/SKILL.md` are kept in sync — change one,
+change all three.
 
 ```markdown
 ### Slide 3: Architecture Overview

package/lib/slides/templates/introduction-v3.html

@@ -465,12 +465,7 @@
 {{#slides}}
 <!-- {{number}}: {{title_en}} -->
 <div class="slide{{#is_cover}} active{{/is_cover}}" data-slide="{{number}}">
-<div class="lang-en">
-{{{body_en}}}
-</div>
-<div class="lang-zh">
-{{{body_zh}}}
-</div>
+{{{slide_inner_html}}}
 {{^is_cover}}<span class="slide-number">{{number_padded}} / {{total_slides}}</span>{{/is_cover}}
 </div>
 {{/slides}}