From bbf24a98e56325d269f1770c7cca8565d6d086e1 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Tue, 30 Jun 2026 04:32:00 +0000
Subject: [PATCH 01/56] rpg_edit: Add a shared CoderMind Explain View renderer
 with `write_com

---
 CoderMind/scripts/check_code_gen.py         |  50 +-
 CoderMind/scripts/common/paths.py           |   2 +
 CoderMind/scripts/common/run_report.py      | 478 ++++++++++++++++++++
 CoderMind/scripts/plan.py                   | 114 ++++-
 CoderMind/scripts/rpg_edit/code.py          |  10 +
 CoderMind/scripts/rpg_edit/locate.py        |  11 +-
 CoderMind/scripts/rpg_edit/review.py        | 174 ++++++-
 CoderMind/scripts/rpg_edit/validate.py      |  14 +-
 CoderMind/scripts/rpg_encoder/run_encode.py |  60 ++-
 CoderMind/scripts/run_batch.py              |  49 ++
 CoderMind/scripts/smoke_test.py             |   8 +-
 CoderMind/scripts/update_graphs.py          |  65 ++-
 CoderMind/tests/test_rpg_edit_run_report.py |  86 ++++
 CoderMind/tests/test_run_report.py          |  83 ++++
 14 files changed, 1177 insertions(+), 27 deletions(-)
 create mode 100644 CoderMind/scripts/common/run_report.py
 create mode 100644 CoderMind/tests/test_rpg_edit_run_report.py
 create mode 100644 CoderMind/tests/test_run_report.py

diff --git a/CoderMind/scripts/check_code_gen.py b/CoderMind/scripts/check_code_gen.py
index f2165ec..387f439 100644
--- a/CoderMind/scripts/check_code_gen.py
+++ b/CoderMind/scripts/check_code_gen.py
@@ -13,9 +13,14 @@
 
 import json
 import argparse
+import sys
 from pathlib import Path
 from typing import Dict, Any, List, Tuple
 
+SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
 # Import centralized paths and state loader
 from common.paths import (
     TASKS_FILE,
@@ -24,6 +29,7 @@
     cmd_for,
     REPO_DIR,
 )
+from common.run_report import write_command_report
 from common.execution_state import load_code_gen_state
 from common.execution_state import load_code_gen_state as _load_state, save_code_gen_state as _save_state
 from common.execution_state import complete_batch as _complete_batch
@@ -427,6 +433,43 @@ def determine_state(
     return result
 
 
+def _write_code_gen_report(result: Dict[str, Any]) -> str | None:
+    try:
+        stats = result.get("stats") or {}
+        report_path = write_command_report(
+            "code_gen",
+            title="CoderMind code_gen Progress View",
+            status=result.get("type"),
+            summary_cards=[
+                {"label": "state", "value": result.get("type", "")},
+                {"label": "total", "value": stats.get("total_tasks", 0)},
+                {"label": "completed", "value": stats.get("completed", 0)},
+                {"label": "failed", "value": stats.get("failed", 0)},
+                {"label": "remaining", "value": stats.get("remaining", 0)},
+                {"label": "current batch", "value": (result.get("current_batch") or {}).get("batch_id", "")},
+                {"label": "next batch", "value": result.get("next_batch", "")},
+            ],
+            stages=[
+                {"name": "determine_state", "status": result.get("type"), "reason": result.get("message", "")},
+                {"name": "current_batch", "status": (result.get("current_batch") or {}).get("phase", "none"), "reason": (result.get("current_batch") or {}).get("file_path", "")},
+                {"name": "next_action", "status": "available" if result.get("next_action") else "missing", "reason": result.get("next_action", "")},
+            ],
+            artifacts={"tasks": TASKS_FILE, "code_gen_state": STATE_FILE},
+            verification=[{"name": "state", "status": result.get("type"), "detail": result.get("message", "")}],
+            evidence={
+                "type": result.get("type"),
+                "stats": stats,
+                "current_batch": result.get("current_batch"),
+                "next_batch": result.get("next_batch"),
+                "next_action": result.get("next_action"),
+            },
+        )
+        return str(report_path)
+    except Exception as exc:
+        result["report_error"] = str(exc)
+        return None
+
+
 def print_status(result: Dict[str, Any], json_output: bool = False) -> None:
     """Print the status in human-readable or JSON format."""
     if json_output:
@@ -474,7 +517,9 @@ def print_status(result: Dict[str, Any], json_output: bool = False) -> None:
     # Next batch info
     if result.get("next_batch"):
         print(f"\n   Next Batch: {result['next_batch']}")
-    
+    if result.get("report_path"):
+        print(f"\n   Report: {result['report_path']}")
+
     # Guidance
     print("\n   " + "─" * 60)
     
@@ -516,6 +561,9 @@ def main():
     args = parser.parse_args()
     
     result = determine_state(args.tasks, args.state)
+    report_path = _write_code_gen_report(result)
+    if report_path:
+        result["report_path"] = report_path
     print_status(result, json_output=args.json)
     
     # Return exit code based on state
diff --git a/CoderMind/scripts/common/paths.py b/CoderMind/scripts/common/paths.py
index bebd0d0..093e651 100644
--- a/CoderMind/scripts/common/paths.py
+++ b/CoderMind/scripts/common/paths.py
@@ -301,6 +301,8 @@ def cmd_for(script_relpath: str) -> str:
 
 RPG_EDIT_PLAN_FILE = DATA_DIR / "rpg_edit_plan.json"
 RPG_EDIT_IMPACT_FILE = DATA_DIR / "rpg_edit_impact.json"
+RPG_EDIT_VALIDATE_FILE = DATA_DIR / "rpg_edit_validate.json"
+RPG_EDIT_LOCATE_FILE = DATA_DIR / "rpg_edit_locate.json"
 RPG_EDIT_CODE_RESULT_FILE = DATA_DIR / "rpg_edit_code_result.json"
 RPG_EDIT_REVIEW_RESULT_FILE = DATA_DIR / "rpg_edit_review_result.json"
 
diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
new file mode 100644
index 0000000..f100477
--- /dev/null
+++ b/CoderMind/scripts/common/run_report.py
@@ -0,0 +1,478 @@
+"""Shared HTML renderer for CoderMind command run reports."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from html import escape
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+from urllib.parse import quote
+
+from common.paths import REPORTS_DIR
+
+_MAX_SUMMARY_CARDS = 7
+
+
+def write_command_report(
+    command: str | None = None,
+    payload: Any = None,
+    *,
+    summary_cards: Any = None,
+    summary: Any = None,
+    stages: Any = None,
+    timeline: Any = None,
+    rpg_nodes: Any = None,
+    dep_nodes: Any = None,
+    artifacts: Any = None,
+    artifact_links: Any = None,
+    verification: Any = None,
+    evidence: Any = None,
+    evidence_json: Any = None,
+    status: str | None = None,
+    title: str | None = None,
+    report_dir: str | Path | None = None,
+    timestamp: str | datetime | None = None,
+    **extra: Any,
+) -> Path:
+    """Write a sanitized Explain View HTML report and return its path."""
+    if isinstance(payload, Mapping):
+        extra = {**dict(payload), **extra}
+    elif payload is not None:
+        extra.setdefault("payload", payload)
+    if command is None:
+        command = str(extra.pop("command", extra.pop("command_name", "command")))
+    summary_cards = summary_cards if summary_cards is not None else extra.pop("summary_cards", None)
+    summary = summary if summary is not None else extra.pop("summary", None)
+    stages = stages if stages is not None else extra.pop("stages", None)
+    timeline = timeline if timeline is not None else extra.pop("timeline", None)
+    rpg_nodes = rpg_nodes if rpg_nodes is not None else extra.pop("rpg_nodes", None)
+    dep_nodes = dep_nodes if dep_nodes is not None else extra.pop("dep_nodes", None)
+    artifacts = artifacts if artifacts is not None else extra.pop("artifacts", None)
+    artifact_links = artifact_links if artifact_links is not None else extra.pop("artifact_links", None)
+    verification = verification if verification is not None else extra.pop("verification", None)
+    evidence = evidence if evidence is not None else extra.pop("evidence", None)
+    evidence_json = evidence_json if evidence_json is not None else extra.pop("evidence_json", None)
+    status = status if status is not None else extra.pop("status", None)
+    title = title if title is not None else extra.pop("title", None)
+    report_dir = report_dir if report_dir is not None else extra.pop("report_dir", None)
+    timestamp = timestamp if timestamp is not None else extra.pop("timestamp", None)
+    summary_cards = summary_cards if summary_cards is not None else summary
+    stages = stages if stages is not None else timeline
+    artifacts = artifacts if artifacts is not None else artifact_links
+    evidence = evidence if evidence is not None else evidence_json
+
+    if rpg_nodes is None:
+        rpg_nodes = extra.pop("rpg_node_evidence", None) or extra.pop("rpg_evidence", None)
+    if dep_nodes is None:
+        dep_nodes = extra.pop("dep_node_evidence", None) or extra.pop("dep_evidence", None)
+    if isinstance(evidence, Mapping):
+        if rpg_nodes is None:
+            rpg_nodes = _evidence_nodes(evidence.get("rpg_nodes")) or _evidence_nodes(evidence.get("rpg_node_evidence"))
+        if dep_nodes is None:
+            dep_nodes = _evidence_nodes(evidence.get("dep_nodes")) or _evidence_nodes(evidence.get("dep_node_evidence"))
+
+    generated_at = _display_timestamp(timestamp)
+    filename_ts = _filename_timestamp(timestamp)
+    safe_command = _slug(command)
+    target_dir = Path(report_dir) if report_dir is not None else REPORTS_DIR
+    target_dir.mkdir(parents=True, exist_ok=True)
+    report_path = _unique_report_path(target_dir / f"cmind_run_{safe_command}_{filename_ts}.html")
+
+    aggregate_evidence = {
+        "command": command,
+        "status": status,
+        "summary_cards": summary_cards,
+        "stages": stages,
+        "rpg_nodes": rpg_nodes,
+        "dep_nodes": dep_nodes,
+        "artifacts": artifacts,
+        "verification": verification,
+        "evidence": evidence,
+    }
+    for key, value in extra.items():
+        aggregate_evidence[key] = value
+
+    page_title = title or f"CoderMind {command} Explain View"
+    html = _render_page(
+        title=page_title,
+        command=command,
+        generated_at=generated_at,
+        status=status,
+        summary_cards=_normalize_cards(summary_cards),
+        stages=_normalize_stages(stages),
+        rpg_nodes=_normalize_nodes(rpg_nodes),
+        dep_nodes=_normalize_nodes(dep_nodes),
+        artifacts=_normalize_artifacts(artifacts),
+        verification=_normalize_verification(verification),
+        evidence=aggregate_evidence,
+    )
+    report_path.write_text(html, encoding="utf-8")
+    return report_path
+
+
+def _slug(value: str) -> str:
+    slug = re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("._-")
+    return slug or "command"
+
+
+def _unique_report_path(path: Path) -> Path:
+    if not path.exists():
+        return path
+    stem = path.stem
+    suffix = path.suffix
+    for index in range(2, 1000):
+        candidate = path.with_name(f"{stem}_{index}{suffix}")
+        if not candidate.exists():
+            return candidate
+    return path.with_name(f"{stem}_{datetime.now(timezone.utc).strftime('%f')}{suffix}")
+
+
+def _display_timestamp(value: str | datetime | None) -> str:
+    if isinstance(value, datetime):
+        return value.astimezone(timezone.utc).isoformat(timespec="seconds")
+    if value is not None:
+        return str(value)
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def _filename_timestamp(value: str | datetime | None) -> str:
+    if isinstance(value, datetime):
+        raw = value.astimezone(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    elif value is not None:
+        raw = str(value)
+    else:
+        raw = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return _slug(raw)
+
+
+def _as_sequence(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, (str, bytes, Path)):
+        return [value]
+    if isinstance(value, Mapping):
+        return list(value.items())
+    if isinstance(value, Sequence):
+        return list(value)
+    return [value]
+
+
+def _normalize_cards(value: Any) -> list[dict[str, Any]]:
+    cards: list[dict[str, Any]] = []
+    if isinstance(value, Mapping):
+        iterable = value.items()
+    else:
+        iterable = _as_sequence(value)
+    for item in iterable:
+        if isinstance(item, tuple) and len(item) == 2:
+            label, card_value = item
+            cards.append({"label": label, "value": card_value})
+        elif isinstance(item, Mapping):
+            label = item.get("label") or item.get("title") or item.get("name") or item.get("key") or "Summary"
+            card_value = item.get("value", item.get("count", item.get("text", "")))
+            detail = item.get("detail") or item.get("description")
+            cards.append({"label": label, "value": card_value, "detail": detail})
+        else:
+            cards.append({"label": "Summary", "value": item})
+    return cards[:_MAX_SUMMARY_CARDS]
+
+
+def _normalize_stages(value: Any) -> list[dict[str, Any]]:
+    stages: list[dict[str, Any]] = []
+    for item in _as_sequence(value):
+        if isinstance(item, tuple) and len(item) == 2:
+            name, state = item
+            stages.append({"name": name, "status": state})
+        elif isinstance(item, Mapping):
+            name = item.get("name") or item.get("stage") or item.get("id") or "stage"
+            status = item.get("status") or item.get("state") or item.get("type") or item.get("action") or "recorded"
+            reason = item.get("reason") or item.get("message") or item.get("description") or ""
+            duration = item.get("duration") or item.get("elapsed") or item.get("elapsed_seconds")
+            stages.append({"name": name, "status": status, "reason": reason, "duration": duration})
+        else:
+            stages.append({"name": item, "status": "recorded"})
+    return stages
+
+
+def _evidence_nodes(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return value
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, Path)):
+        return value
+    return None
+
+
+def _normalize_nodes(value: Any) -> list[dict[str, Any]]:
+    nodes: list[dict[str, Any]] = []
+    for item in _as_sequence(value):
+        if isinstance(item, tuple) and len(item) == 2:
+            node_id, node_value = item
+            if isinstance(node_value, Mapping):
+                entry = {"node_id": node_id, **dict(node_value)}
+            else:
+                entry = {"node_id": node_id, "value": node_value}
+        elif isinstance(item, Mapping):
+            entry = dict(item)
+        else:
+            entry = {"node_id": item}
+        nodes.append(entry)
+    return nodes
+
+
+def _normalize_artifacts(value: Any) -> list[dict[str, Any]]:
+    artifacts: list[dict[str, Any]] = []
+    if isinstance(value, Mapping):
+        iterable = value.items()
+    else:
+        iterable = _as_sequence(value)
+    for item in iterable:
+        if isinstance(item, tuple) and len(item) == 2:
+            label, path = item
+            artifacts.append({"label": label, "path": path})
+        elif isinstance(item, Mapping):
+            path = item.get("path") or item.get("href") or item.get("url") or item.get("file")
+            label = item.get("label") or item.get("name") or item.get("title") or path or "artifact"
+            artifacts.append({"label": label, "path": path, "status": item.get("status")})
+        else:
+            artifacts.append({"label": Path(str(item)).name or "artifact", "path": item})
+    return artifacts
+
+
+def _normalize_verification(value: Any) -> list[dict[str, Any]]:
+    checks: list[dict[str, Any]] = []
+    if isinstance(value, Mapping) and not any(isinstance(v, Mapping) for v in value.values()):
+        for key, check_value in value.items():
+            checks.append({"name": key, "status": check_value})
+        return checks
+    if isinstance(value, Mapping):
+        iterable = value.items()
+    else:
+        iterable = _as_sequence(value)
+    for item in iterable:
+        if isinstance(item, tuple) and len(item) == 2:
+            name, check_value = item
+            if isinstance(check_value, Mapping):
+                checks.append({"name": name, **dict(check_value)})
+            else:
+                checks.append({"name": name, "status": check_value})
+        elif isinstance(item, Mapping):
+            name = item.get("name") or item.get("check") or item.get("label") or "verification"
+            checks.append({"name": name, **dict(item)})
+        else:
+            checks.append({"name": "verification", "status": item})
+    return checks
+
+
+def _render_page(
+    *,
+    title: str,
+    command: str,
+    generated_at: str,
+    status: str | None,
+    summary_cards: list[dict[str, Any]],
+    stages: list[dict[str, Any]],
+    rpg_nodes: list[dict[str, Any]],
+    dep_nodes: list[dict[str, Any]],
+    artifacts: list[dict[str, Any]],
+    verification: list[dict[str, Any]],
+    evidence: Mapping[str, Any],
+) -> str:
+    status_html = f"<span class=\"status\">{_h(status)}</span>" if status else ""
+    return f"""<!doctype html>
+<html lang=\"en\">
+<head>
+<meta charset=\"utf-8\">
+<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">
+<title>{_h(title)}</title>
+<style>
+:root {{ color-scheme: light; --bg:#f6f8fb; --card:#fff; --text:#1f2937; --muted:#6b7280; --line:#d9e0ea; --accent:#2563eb; }}
+body {{ margin:0; font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; background:var(--bg); color:var(--text); }}
+main {{ max-width:1120px; margin:0 auto; padding:32px 20px 48px; }}
+header {{ margin-bottom:24px; }}
+h1 {{ margin:0 0 8px; font-size:30px; }}
+.meta {{ color:var(--muted); font-size:14px; display:flex; flex-wrap:wrap; gap:12px; }}
+.status {{ border:1px solid var(--line); border-radius:999px; padding:2px 10px; background:#eef4ff; color:#174ea6; }}
+section {{ background:var(--card); border:1px solid var(--line); border-radius:14px; margin:16px 0; padding:18px; box-shadow:0 1px 2px rgba(15,23,42,.04); }}
+h2 {{ margin:0 0 14px; font-size:18px; }}
+.cards {{ display:grid; grid-template-columns:repeat(auto-fit,minmax(150px,1fr)); gap:12px; }}
+.card {{ border:1px solid var(--line); border-radius:12px; padding:14px; background:#fbfdff; }}
+.card-wide {{ grid-column:span 2; }}
+.card-label {{ color:var(--muted); font-size:12px; text-transform:uppercase; letter-spacing:.04em; }}
+.card-value {{ margin-top:6px; font-size:22px; font-weight:700; word-break:break-word; overflow-wrap:anywhere; }}
+.card-value-long {{ font-size:14px; line-height:1.35; font-weight:600; }}
+.card-detail {{ margin-top:5px; color:var(--muted); font-size:13px; }}
+.timeline {{ list-style:none; margin:0; padding:0; }}
+.timeline li {{ border-left:3px solid var(--accent); padding:0 0 14px 14px; margin-left:6px; }}
+.timeline li:last-child {{ padding-bottom:0; }}
+.stage-head {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; }}
+.badge {{ font-size:12px; border-radius:999px; background:#eef2f7; padding:2px 8px; color:#334155; }}
+.reason {{ color:var(--muted); margin-top:4px; }}
+table {{ width:100%; border-collapse:collapse; font-size:14px; table-layout:fixed; }}
+th, td {{ border-top:1px solid var(--line); padding:8px 10px; text-align:left; vertical-align:top; overflow-wrap:anywhere; word-break:break-word; }}
+th {{ color:var(--muted); font-weight:600; background:#fbfdff; }}
+code {{ white-space:normal; overflow-wrap:anywhere; word-break:break-word; }}
+a {{ color:var(--accent); text-decoration:none; overflow-wrap:anywhere; word-break:break-word; }}
+a:hover {{ text-decoration:underline; }}
+.empty {{ color:var(--muted); font-style:italic; }}
+pre {{ white-space:pre-wrap; overflow:auto; background:#0f172a; color:#e5e7eb; border-radius:10px; padding:14px; }}
+details summary {{ cursor:pointer; color:var(--accent); font-weight:600; }}
+</style>
+</head>
+<body>
+<main>
+<header>
+<h1>{_h(title)}</h1>
+<div class=\"meta\"><span>Command: <strong>{_h(command)}</strong></span><span>Generated: {_h(generated_at)}</span>{status_html}</div>
+</header>
+{_render_summary_cards(summary_cards)}
+{_render_timeline(stages)}
+{_render_verification(verification)}
+{_render_node_table("Focused RPG node evidence", rpg_nodes)}
+{_render_node_table("Focused dependency node evidence", dep_nodes)}
+{_render_artifacts(artifacts)}
+{_render_evidence(evidence)}
+</main>
+</body>
+</html>
+"""
+
+
+def _render_summary_cards(cards: list[dict[str, Any]]) -> str:
+    if not cards:
+        body = "<p class=\"empty\">No summary cards recorded.</p>"
+    else:
+        rendered_cards = []
+        for card in cards:
+            detail = card.get("detail")
+            detail_html = ""
+            if detail is not None:
+                detail_html = f"<div class=\"card-detail\">{_h(detail)}</div>"
+            value = card.get("value", "")
+            long_value = len(str(value)) > 48
+            card_class = "card card-wide" if long_value else "card"
+            value_class = "card-value card-value-long" if long_value else "card-value"
+            rendered_cards.append(
+                f"<div class=\"{card_class}\"><div class=\"card-label\">{_h(card.get('label', 'Summary'))}</div>"
+                f"<div class=\"{value_class}\">{_h(value)}</div>"
+                f"{detail_html}</div>"
+            )
+        body = '<div class="cards">' + "".join(rendered_cards) + "</div>"
+    return f"<section><h2>Summary</h2>{body}</section>"
+
+
+def _render_timeline(stages: list[dict[str, Any]]) -> str:
+    if not stages:
+        body = "<p class=\"empty\">No stages recorded.</p>"
+    else:
+        items = []
+        for stage in stages:
+            duration = stage.get("duration")
+            duration_text = f"<span class=\"badge\">{_h(duration)}s</span>" if duration not in (None, "") else ""
+            items.append(
+                "<li>"
+                f"<div class=\"stage-head\"><strong>{_h(stage.get('name', 'stage'))}</strong>"
+                f"<span class=\"badge\">{_h(stage.get('status', 'recorded'))}</span>{duration_text}</div>"
+                f"<div class=\"reason\">{_h(stage.get('reason', ''))}</div>"
+                "</li>"
+            )
+        body = '<ol class="timeline">' + "".join(items) + "</ol>"
+    return f"<section><h2>Stage timeline</h2>{body}</section>"
+
+
+def _render_verification(checks: list[dict[str, Any]]) -> str:
+    if not checks:
+        body = "<p class=\"empty\">No verification status recorded.</p>"
+    else:
+        rows = []
+        for check in checks:
+            rows.append(
+                "<tr>"
+                f"<td>{_h(check.get('name') or check.get('check') or 'verification')}</td>"
+                f"<td>{_h(check.get('status', check.get('success', '')))}</td>"
+                f"<td>{_h(check.get('detail') or check.get('message') or check.get('reason') or '')}</td>"
+                "</tr>"
+            )
+        body = "<table><thead><tr><th>Check</th><th>Status</th><th>Detail</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+    return f"<section><h2>Verification status</h2>{body}</section>"
+
+
+def _render_node_table(title: str, nodes: list[dict[str, Any]]) -> str:
+    if not nodes:
+        body = "<p class=\"empty\">No node evidence recorded.</p>"
+    else:
+        rows = []
+        for node in nodes:
+            node_id = node.get("node_id") or node.get("id") or node.get("dep_node") or ""
+            node_type = node.get("type_name") or node.get("node_type") or node.get("type") or ""
+            path = node.get("meta_path") or node.get("path") or node.get("file_path") or node.get("feature_path") or ""
+            score = node.get("score") or node.get("weight") or node.get("status") or ""
+            rows.append(
+                "<tr>"
+                f"<td><code>{_h(node_id)}</code></td>"
+                f"<td>{_h(node.get('name', ''))}</td>"
+                f"<td>{_h(node_type)}</td>"
+                f"<td>{_h(path)}</td>"
+                f"<td>{_h(score)}</td>"
+                "</tr>"
+            )
+        body = "<table><thead><tr><th>ID</th><th>Name</th><th>Type</th><th>Path</th><th>Score/status</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+    return f"<section><h2>{_h(title)}</h2>{body}</section>"
+
+
+def _render_artifacts(artifacts: list[dict[str, Any]]) -> str:
+    if not artifacts:
+        body = "<p class=\"empty\">No artifact links recorded.</p>"
+    else:
+        rows = []
+        for artifact in artifacts:
+            path = artifact.get("path")
+            href = _artifact_href(path)
+            rows.append(
+                "<tr>"
+                f"<td>{_h(artifact.get('label', 'artifact'))}</td>"
+                f"<td><a href=\"{_h_attr(href)}\">{_h(path or '')}</a></td>"
+                f"<td>{_h(artifact.get('status', ''))}</td>"
+                "</tr>"
+            )
+        body = "<table><thead><tr><th>Artifact</th><th>Path</th><th>Status</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+    return f"<section><h2>Artifact links</h2>{body}</section>"
+
+
+def _render_evidence(evidence: Mapping[str, Any]) -> str:
+    data = json.dumps(evidence, indent=2, ensure_ascii=False, default=_json_default)
+    return f"<section><details><summary>Evidence JSON</summary><pre>{_h(data)}</pre></details></section>"
+
+
+def _artifact_href(path: Any) -> str:
+    if path is None:
+        return "#"
+    try:
+        return Path(str(path)).expanduser().resolve().as_uri()
+    except Exception:
+        return "file://" + quote(str(path), safe="/._-~")
+
+
+def _json_default(value: Any) -> Any:
+    if isinstance(value, Path):
+        return str(value)
+    if hasattr(value, "to_dict"):
+        return value.to_dict()
+    if hasattr(value, "__dict__"):
+        return value.__dict__
+    return str(value)
+
+
+def _h(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, (dict, list, tuple)):
+        value = json.dumps(value, ensure_ascii=False, default=_json_default)
+    return escape(str(value), quote=False)
+
+
+def _h_attr(value: Any) -> str:
+    if value is None:
+        return ""
+    return escape(str(value), quote=True)
diff --git a/CoderMind/scripts/plan.py b/CoderMind/scripts/plan.py
index 90c2cd5..6a3a421 100644
--- a/CoderMind/scripts/plan.py
+++ b/CoderMind/scripts/plan.py
@@ -58,7 +58,19 @@
 # Sub-scripts live in the same directory as this file (bundled under
 # cmind_cli/core_pack/scripts/ in the installed wheel).
 _SCRIPTS_DIR = Path(__file__).resolve().parent
-
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from common.paths import (
+    BASE_CLASSES_FILE,
+    DATA_FLOW_FILE,
+    DATA_FLOW_VIZ_FILE,
+    INTERFACES_FILE,
+    SKELETON_FILE,
+    SKELETON_SUMMARY_FILE,
+    TASKS_FILE,
+)
+from common.run_report import write_command_report
 
 # ---------------------------------------------------------------------------
 # Stage table — single source of truth for the pipeline.
@@ -278,10 +290,7 @@ def decide(states: list[StageState], force: bool) -> None:
             state.reason = "up-to-date"
         else:
             state.will_run = True
-            if state.type == "warning":
-                state.reason = "warning: cross-stage contract violation; rebuild stage and downstream"
-            else:
-                state.reason = f"type={state.type}"
+            state.reason = f"type={state.type}"
             cascade = True
 
 
@@ -292,6 +301,88 @@ def decide(states: list[StageState], force: bool) -> None:
 _GLYPH = {"update": "✓", "init": "·", "warning": "!", "error": "✗"}
 
 
+def _stage_rows(states: list[StageState]) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for state in states:
+        rows.append({
+            "name": state.stage.name,
+            "status": "run" if state.will_run else "skip",
+            "type": state.type,
+            "done": state.done,
+            "reason": state.reason or state.message,
+            "message": state.message,
+        })
+    return rows
+
+
+def _plan_artifacts() -> list[dict[str, Any]]:
+    paths = {
+        "skeleton": SKELETON_FILE,
+        "skeleton_summary": SKELETON_SUMMARY_FILE,
+        "data_flow": DATA_FLOW_FILE,
+        "data_flow_viz": DATA_FLOW_VIZ_FILE,
+        "base_classes": BASE_CLASSES_FILE,
+        "interfaces": INTERFACES_FILE,
+        "tasks": TASKS_FILE,
+    }
+    return [
+        {"label": label, "path": str(path), "status": "available" if path.exists() else "missing"}
+        for label, path in paths.items()
+    ]
+
+
+def _write_plan_report(
+    states: list[StageState],
+    *,
+    mode: str,
+    elapsed: float | None = None,
+    post_steps: list[dict[str, Any]] | None = None,
+) -> str | None:
+    try:
+        done = sum(1 for s in states if s.done)
+        runnable = sum(1 for s in states if s.will_run)
+        cards = [
+            {"label": "mode", "value": mode},
+            {"label": "stages", "value": len(states)},
+            {"label": "done", "value": done},
+            {"label": "to run", "value": runnable},
+            {"label": "skipped", "value": len(states) - runnable},
+        ]
+        if elapsed is not None:
+            cards.append({"label": "elapsed", "value": f"{elapsed:.1f}s"})
+        if post_steps is not None:
+            cards.append({"label": "post steps", "value": len(post_steps)})
+        timeline = _stage_rows(states)
+        for post in post_steps or []:
+            timeline.append({
+                "name": post.get("name", "post-step"),
+                "status": "ok" if post.get("returncode") == 0 else "warning",
+                "reason": f"exit {post.get('returncode')}",
+            })
+        report_path = write_command_report(
+            "plan",
+            title="CoderMind plan Explain View",
+            status=mode,
+            summary_cards=cards,
+            stages=timeline,
+            artifacts=_plan_artifacts(),
+            verification=[
+                {"name": s.stage.name, "status": s.type, "detail": s.message or s.reason}
+                for s in states
+            ],
+            evidence={
+                "mode": mode,
+                "elapsed": elapsed,
+                "stages": _stage_rows(states),
+                "post_steps": post_steps or [],
+                "artifacts": _plan_artifacts(),
+            },
+        )
+        return str(report_path)
+    except Exception:
+        return None
+
+
 def _format_table(states: list[StageState]) -> str:
     rows = ["Stage           Type     Done   Action"]
     rows.append("-" * 50)
@@ -322,6 +413,7 @@ def _emit_check_only_json(states: list[StageState]) -> None:
     done = sum(1 for s in states if s.done)
     total = len(states)
     next_pending = next((s.stage.name for s in states if not s.done), None)
+    report_path = _write_plan_report(states, mode="check-only")
     payload = {
         "total": total,
         "done": done,
@@ -332,10 +424,14 @@ def _emit_check_only_json(states: list[StageState]) -> None:
                 "type": s.type,
                 "message": s.message,
                 "done": s.done,
+                "will_run": s.will_run,
+                "reason": s.reason,
             }
             for s in states
         ],
     }
+    if report_path:
+        payload["report_path"] = report_path
     print(json.dumps(payload, indent=2))
 
 
@@ -436,6 +532,9 @@ def main(argv: Optional[list[str]] = None) -> int:
             _emit_check_only_json(states)
         else:
             _print_probe_summary(states)
+            report_path = _write_plan_report(states, mode="check-only")
+            if report_path:
+                print(f"Report: {report_path}")
         return 0
 
     # --- Step: prerequisite check -----------------------------------------
@@ -521,15 +620,20 @@ def main(argv: Optional[list[str]] = None) -> int:
     # --- Step: post-pipeline helpers --------------------------------------
     print()
     print("Running post-pipeline helpers ...")
+    post_results: list[dict[str, Any]] = []
     for post in POST_STEPS:
         print(f"▶  {post}")
         rc = _run_stage(invoker, post, [])
+        post_results.append({"name": post, "returncode": rc})
         if rc != 0:
             print(f"   warning: {post} exited with {rc} (continuing)")
 
     total_elapsed = time.monotonic() - started
+    report_path = _write_plan_report(states, mode="complete", elapsed=total_elapsed, post_steps=post_results)
     print()
     print(f"Plan complete in {total_elapsed:.1f}s.")
+    if report_path:
+        print(f"Report: {report_path}")
     print("Next: `/cmind.code_gen` to generate source code.")
     print("Graph: see the 'Writing visualization to:' line above for the generated HTML path.")
     return 0
diff --git a/CoderMind/scripts/rpg_edit/code.py b/CoderMind/scripts/rpg_edit/code.py
index c070be7..4c7e2f2 100644
--- a/CoderMind/scripts/rpg_edit/code.py
+++ b/CoderMind/scripts/rpg_edit/code.py
@@ -43,6 +43,7 @@
     RPG_FILE,
     REPO_DIR,
     RPG_EDIT_PLAN_FILE,
+    RPG_EDIT_CODE_RESULT_FILE,
     DATA_DIR,
     WORKSPACE_ROOT,
     cmd_for,
@@ -52,6 +53,14 @@
 logger = logging.getLogger(__name__)
 
 
+def _write_code_result(result: Dict[str, Any]) -> None:
+    RPG_EDIT_CODE_RESULT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    RPG_EDIT_CODE_RESULT_FILE.write_text(
+        json.dumps(result, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
 # ---------------------------------------------------------------------------
 # Prompt templates
 # ---------------------------------------------------------------------------
@@ -684,6 +693,7 @@ def main() -> int:
         max_iterations=args.max_iterations,
         timeout=args.timeout,
     )
+    _write_code_result(result)
 
     if args.json:
         print(json.dumps(result, indent=2, ensure_ascii=False))
diff --git a/CoderMind/scripts/rpg_edit/locate.py b/CoderMind/scripts/rpg_edit/locate.py
index 082b819..43492c6 100644
--- a/CoderMind/scripts/rpg_edit/locate.py
+++ b/CoderMind/scripts/rpg_edit/locate.py
@@ -20,7 +20,15 @@
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
-from common.paths import REPO_RPG_FILE  # noqa: E402
+from common.paths import REPO_RPG_FILE, RPG_EDIT_LOCATE_FILE  # noqa: E402
+
+
+def _write_locate_result(result: dict) -> None:
+    RPG_EDIT_LOCATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    RPG_EDIT_LOCATE_FILE.write_text(
+        json.dumps(result, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
 
 
 def _build_tree_summary(svc, max_depth: int = 3, max_lines: int = 150) -> List[str]:
@@ -198,6 +206,7 @@ def main():
     # when search results are poor (e.g. editing features that don't exist yet).
     tree_lines = _build_tree_summary(svc)
     output["tree_summary"] = tree_lines
+    _write_locate_result(output)
 
     if args.json:
         print(json.dumps(output, indent=2, ensure_ascii=False))
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 85b8386..45af3ce 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -34,10 +34,161 @@
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
-from common.paths import REPO_DIR, cmd_for, RPG_EDIT_PLAN_FILE, RPG_EDIT_IMPACT_FILE  # noqa: E402
+from common.paths import (  # noqa: E402
+    REPO_DIR,
+    cmd_for,
+    RPG_EDIT_PLAN_FILE,
+    RPG_EDIT_IMPACT_FILE,
+    RPG_EDIT_VALIDATE_FILE,
+    RPG_EDIT_LOCATE_FILE,
+    RPG_EDIT_CODE_RESULT_FILE,
+    RPG_EDIT_REVIEW_RESULT_FILE,
+)
+from common.run_report import write_command_report  # noqa: E402
 
 logger = logging.getLogger(__name__)
 
+
+def _write_review_result(result: Dict[str, Any]) -> None:
+    RPG_EDIT_REVIEW_RESULT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    RPG_EDIT_REVIEW_RESULT_FILE.write_text(
+        json.dumps(result, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
+def _load_json_artifact(path: Optional[Path]) -> Any:
+    if path is None or not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        return {"_error": str(exc), "_path": str(path)}
+
+
+def _load_review_artifacts(plan_path: Path, impact_path: Optional[Path]) -> Dict[str, Any]:
+    return {
+        "validate": _load_json_artifact(RPG_EDIT_VALIDATE_FILE),
+        "locate": _load_json_artifact(RPG_EDIT_LOCATE_FILE),
+        "plan": _load_json_artifact(plan_path),
+        "impact": _load_json_artifact(impact_path),
+        "code_result": _load_json_artifact(RPG_EDIT_CODE_RESULT_FILE),
+    }
+
+
+def _artifact_links(plan_path: Path, impact_path: Optional[Path]) -> List[Dict[str, Any]]:
+    paths = {
+        "validate": RPG_EDIT_VALIDATE_FILE,
+        "locate": RPG_EDIT_LOCATE_FILE,
+        "plan": plan_path,
+        "impact": impact_path,
+        "code_result": RPG_EDIT_CODE_RESULT_FILE,
+        "review_result": RPG_EDIT_REVIEW_RESULT_FILE,
+    }
+    links: List[Dict[str, Any]] = []
+    for label, path in paths.items():
+        if path is None:
+            continue
+        status = "available" if path.exists() or label == "review_result" else "missing"
+        links.append({"label": label, "path": str(path), "status": status})
+    return links
+
+
+def _selected_candidate_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
+    locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
+    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
+    affected = set(plan.get("affected_nodes") or [])
+    candidates = locate.get("results") or []
+    if affected:
+        candidates = [c for c in candidates if c.get("node_id") in affected]
+    return [c for c in candidates if isinstance(c, dict)]
+
+
+def _dep_node_rows(candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    for candidate in candidates:
+        for dep_id in candidate.get("dep_nodes") or []:
+            rows.append({
+                "node_id": dep_id,
+                "source_feature": candidate.get("node_id"),
+                "path": candidate.get("meta_path"),
+            })
+    return rows
+
+
+def _review_summary_cards(result: Dict[str, Any], artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
+    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
+    locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
+    return [
+        {"label": "review", "value": result.get("type", "review")},
+        {"label": "success", "value": result.get("success", result.get("type") == "skipped")},
+        {"label": "iterations", "value": len(result.get("iterations") or [])},
+        {"label": "files", "value": len(code_result.get("files_modified") or [])},
+        {"label": "candidates", "value": len(locate.get("results") or [])},
+        {"label": "affected nodes", "value": len(plan.get("affected_nodes") or [])},
+        {"label": "suggestions", "value": len(result.get("suggestions") or [])},
+    ]
+
+
+def _review_timeline(result: Dict[str, Any], artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
+    validate = artifacts.get("validate") if isinstance(artifacts.get("validate"), dict) else None
+    locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else None
+    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else None
+    impact = artifacts.get("impact") if isinstance(artifacts.get("impact"), dict) else None
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else None
+    return [
+        {"name": "validate", "status": validate.get("type") if validate else "missing", "reason": validate.get("message", "") if validate else "artifact not found"},
+        {"name": "locate", "status": locate.get("type") if locate else "missing", "reason": f"{len(locate.get('results') or [])} candidates" if locate else "artifact not found"},
+        {"name": "plan", "status": "available" if plan else "missing", "reason": f"{len(plan.get('code_changes') or [])} code changes" if plan else "artifact not found"},
+        {"name": "impact", "status": impact.get("type", "available") if impact else "missing", "reason": f"{len((impact.get('results') or {}))} impact result sets" if impact else "artifact not found"},
+        {"name": "code", "status": code_result.get("last_status") if code_result else "missing", "reason": code_result.get("last_error") or f"success={code_result.get('success')}" if code_result else "artifact not found"},
+        {"name": "review", "status": result.get("type"), "reason": result.get("reason") or f"success={result.get('success')}"},
+    ]
+
+
+def _review_verification(result: Dict[str, Any], artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
+    checks: List[Dict[str, Any]] = []
+    validate = artifacts.get("validate") if isinstance(artifacts.get("validate"), dict) else None
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else None
+    if validate:
+        checks.append({"name": "validate", "status": validate.get("type"), "detail": validate.get("message", "")})
+    if code_result:
+        checks.append({"name": "code", "status": code_result.get("success"), "detail": code_result.get("last_error") or code_result.get("last_status")})
+    checks.append({"name": "review", "status": result.get("success", result.get("type") == "skipped"), "detail": result.get("reason") or result.get("type")})
+    for iteration in result.get("iterations") or []:
+        checks.append({
+            "name": f"review iteration {iteration.get('iteration')}",
+            "status": iteration.get("post_pytest_passed"),
+            "detail": iteration.get("agent_detail", ""),
+        })
+    return checks
+
+
+def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path: Optional[Path]) -> Dict[str, Any]:
+    _write_review_result(result)
+    artifacts = _load_review_artifacts(plan_path, impact_path)
+    candidates = _selected_candidate_rows(artifacts)
+    try:
+        report_path = write_command_report(
+            "rpg_edit",
+            title="CoderMind rpg_edit Explain View",
+            status=str(result.get("type", "review")),
+            summary_cards=_review_summary_cards(result, artifacts),
+            stages=_review_timeline(result, artifacts),
+            rpg_nodes=candidates,
+            dep_nodes=_dep_node_rows(candidates),
+            artifacts=_artifact_links(plan_path, impact_path),
+            verification=_review_verification(result, artifacts),
+            evidence={"artifacts": artifacts, "review_result": result},
+        )
+        result["report_path"] = str(report_path)
+    except Exception as exc:
+        result["report_error"] = str(exc)
+    _write_review_result(result)
+    return result
+
+
 # ---------------------------------------------------------------------------
 # Review prompt template
 # ---------------------------------------------------------------------------
@@ -546,7 +697,7 @@ def impact_review(
                 all_suggestions.append(s)
     if all_suggestions:
         results["suggestions"] = all_suggestions
-    return results
+    return _publish_review_report(results, plan_path, impact_path)
 
 
 # ---------------------------------------------------------------------------
@@ -583,6 +734,7 @@ def main():
 
     if not args.plan.exists():
         result = {"type": "error", "message": f"Plan not found: {args.plan}"}
+        result = _publish_review_report(result, args.plan, args.impact)
         print(json.dumps(result) if args.json else f"Error: {result['message']}")
         return 1
 
@@ -599,12 +751,14 @@ def main():
         if total_callers == 0 and affected_files <= 1:
             result = {
                 "type": "skipped",
+                "success": True,
                 "reason": f"Impact too small for sub-agent review "
                           f"(callers={total_callers}, files={affected_files}). "
                           f"Agent self-review is sufficient.",
             }
+            result = _publish_review_report(result, args.plan, args.impact)
             print(json.dumps(result, indent=2) if args.json else
-                  f"Skipped: {result['reason']}")
+                  f"Skipped: {result['reason']}\nReport: {result.get('report_path', '')}")
             return 0
 
     result = impact_review(
@@ -615,10 +769,16 @@ def main():
         timeout=args.timeout,
     )
 
-    print(json.dumps(result, indent=2) if args.json else
-          f"Review {'PASSED' if result['success'] else 'FAILED'} "
-          f"({len(result['iterations'])} iterations, "
-          f"{result['total_duration']:.1f}s)")
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        print(
+            f"Review {'PASSED' if result['success'] else 'FAILED'} "
+            f"({len(result['iterations'])} iterations, "
+            f"{result['total_duration']:.1f}s)"
+        )
+        if result.get("report_path"):
+            print(f"Report: {result['report_path']}")
     return 0 if result["success"] else 1
 
 
diff --git a/CoderMind/scripts/rpg_edit/validate.py b/CoderMind/scripts/rpg_edit/validate.py
index e52f7b0..d098fee 100644
--- a/CoderMind/scripts/rpg_edit/validate.py
+++ b/CoderMind/scripts/rpg_edit/validate.py
@@ -12,7 +12,15 @@
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
-from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE  # noqa: E402
+from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE, RPG_EDIT_VALIDATE_FILE  # noqa: E402
+
+
+def _write_validate_result(result: dict) -> None:
+    RPG_EDIT_VALIDATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    RPG_EDIT_VALIDATE_FILE.write_text(
+        json.dumps(result, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
 
 
 def main():
@@ -31,6 +39,7 @@ def main():
     if not args.rpg.exists():
         result = {"type": "error", "error_code": "rpg_not_found",
                   "message": f"RPG file not found: {args.rpg}"}
+        _write_validate_result(result)
         print(json.dumps(result) if args.json else f"Error: {result['message']}")
         return 1
 
@@ -40,6 +49,7 @@ def main():
     except Exception as e:
         result = {"type": "error", "error_code": "rpg_load_failed",
                   "message": f"Failed to load RPG: {e}"}
+        _write_validate_result(result)
         print(json.dumps(result) if args.json else f"Error: {result['message']}")
         return 1
 
@@ -52,6 +62,7 @@ def main():
                       "Run /cmind.encode to (re)build it; the embedded "
                       "dep_graph rides inside rpg.json."
                   )}
+        _write_validate_result(result)
         print(json.dumps(result) if args.json else f"Error: {result['message']}")
         return 1
 
@@ -64,6 +75,7 @@ def main():
         "dep_to_rpg": len(svc.rpg._dep_to_rpg_map),
         "feature_to_dep": len(svc.rpg._feature_to_dep_map),
     }
+    _write_validate_result(result)
     print(json.dumps(result, indent=2) if args.json else
           f"Ready: {result['nodes']} nodes, dep_graph={'yes' if has_dep_graph else 'no'}")
     return 0
diff --git a/CoderMind/scripts/rpg_encoder/run_encode.py b/CoderMind/scripts/rpg_encoder/run_encode.py
index d9ed2a0..f159dfb 100644
--- a/CoderMind/scripts/rpg_encoder/run_encode.py
+++ b/CoderMind/scripts/rpg_encoder/run_encode.py
@@ -27,9 +27,52 @@
 
 from common.paths import RPG_FILE, RPG_HTML_FILE, WORKSPACE_ROOT, ensure_cmind_dir  # noqa: E402
 from common.rpg_io import atomic_write_rpg  # noqa: E402
+from common.run_report import write_command_report  # noqa: E402
 from common.trajectory import Trajectory  # noqa: E402
 
 
+def _attach_encode_report(result: dict) -> dict:
+    try:
+        dep_summary = []
+        if result.get("dep_nodes") is not None:
+            dep_summary.append(f"nodes={result.get('dep_nodes')}")
+        if result.get("dep_edges") is not None:
+            dep_summary.append(f"edges={result.get('dep_edges')}")
+        if result.get("dep_to_rpg_map_size") is not None:
+            dep_summary.append(f"mapped={result.get('dep_to_rpg_map_size')}")
+        report_path = write_command_report(
+            "encode",
+            title="CoderMind encode Explain View",
+            status=result.get("status"),
+            summary_cards=[
+                {"label": "repo", "value": result.get("repo_name", "unknown")},
+                {"label": "RPG nodes", "value": result.get("node_count", 0)},
+                {"label": "RPG edges", "value": result.get("edge_count", 0)},
+                {"label": "dep graph", "value": ", ".join(dep_summary) or "not recorded"},
+                {"label": "output", "value": result.get("output_path", "")},
+                {"label": "visualization", "value": result.get("viz_path", result.get("viz_error", ""))},
+                {"label": "trajectory", "value": result.get("trajectory", "")},
+            ],
+            stages=[
+                {"name": "parse_rpg", "status": "recorded", "reason": f"nodes={result.get('node_count', 0)}, edges={result.get('edge_count', 0)}"},
+                {"name": "dep_graph", "status": "recorded" if dep_summary else "not recorded", "reason": ", ".join(dep_summary)},
+                {"name": "save_rpg", "status": "recorded" if result.get("output_path") else "not recorded", "reason": result.get("output_path", "")},
+                {"name": "visualize", "status": "recorded" if result.get("viz_path") else "not recorded", "reason": result.get("viz_path") or result.get("viz_error", "")},
+            ],
+            artifacts={
+                "rpg_json": result.get("output_path"),
+                "rpg_html": result.get("viz_path"),
+                "trajectory": result.get("trajectory"),
+            },
+            verification={"encode": result.get("status")},
+            evidence=result,
+        )
+        result["report_path"] = str(report_path)
+    except Exception as exc:
+        result["report_error"] = str(exc)
+    return result
+
+
 def run_encode(
     repo_dir: str | None = None,
     repo_name: str | None = None,
@@ -54,7 +97,12 @@ def run_encode(
     repo_dir = os.path.abspath(repo_dir)
 
     if not os.path.isdir(repo_dir):
-        return {"status": "error", "error": f"Repository directory not found: {repo_dir}"}
+        return _attach_encode_report({
+            "status": "error",
+            "error": f"Repository directory not found: {repo_dir}",
+            "repo_name": repo_name or os.path.basename(repo_dir) or "unknown",
+            "output_path": output or str(RPG_FILE),
+        })
 
     if repo_name is None:
         repo_name = os.path.basename(repo_dir) or "unknown"
@@ -188,12 +236,18 @@ def run_encode(
         traj.complete(stats)
         stats["trajectory"] = str(traj.trajectory_file)
 
-        return {"status": "success", **stats}
+        return _attach_encode_report({"status": "success", **stats})
 
     except Exception as exc:
         logger.exception("Encoding failed: %s", exc)
         traj.fail(str(exc))
-        return {"status": "error", "error": str(exc), "trajectory": str(traj.trajectory_file)}
+        return _attach_encode_report({
+            "status": "error",
+            "error": str(exc),
+            "repo_name": repo_name,
+            "output_path": output,
+            "trajectory": str(traj.trajectory_file),
+        })
 
 
 def main():
diff --git a/CoderMind/scripts/run_batch.py b/CoderMind/scripts/run_batch.py
index d2ed385..d31555c 100644
--- a/CoderMind/scripts/run_batch.py
+++ b/CoderMind/scripts/run_batch.py
@@ -65,6 +65,7 @@
     cmd_for,
     REPO_DIR,
 )
+from common.run_report import write_command_report
 from code_gen.context_collector import build_dependency_context
 from code_gen.prompts import (
     build_test_prompt_from_batch,
@@ -923,8 +924,53 @@ def run_batch(
 # CLI
 # ============================================================================
 
+def _write_batch_report(result: Dict[str, Any]) -> Optional[str]:
+    if result.get("type") not in {"batch_complete", "batch_failed", "final_test", "complete"}:
+        return None
+    try:
+        stats = result.get("stats") or {}
+        report_path = write_command_report(
+            "code_gen",
+            title="CoderMind code_gen Batch View",
+            status=result.get("type"),
+            summary_cards=[
+                {"label": "result", "value": result.get("type", "")},
+                {"label": "success", "value": result.get("success", "")},
+                {"label": "batch", "value": result.get("batch_id", "")},
+                {"label": "attempts", "value": result.get("attempts_used", "")},
+                {"label": "duration", "value": f"{result.get('total_duration', 0):.1f}s" if "total_duration" in result else ""},
+                {"label": "completed", "value": stats.get("completed", "")},
+                {"label": "failed", "value": stats.get("failed", result.get("failed", ""))},
+            ],
+            stages=[
+                {"name": "batch", "status": result.get("type"), "reason": result.get("failure_reason") or result.get("message", "")},
+                {"name": "verification", "status": result.get("success"), "reason": f"passed={result.get('passed', '')} failed={result.get('failed', '')} errors={result.get('errors', '')}"},
+                {"name": "next_action", "status": "available" if result.get("next_action") else "missing", "reason": result.get("next_action", "")},
+            ],
+            artifacts={
+                "feature_spec": FEATURE_SPEC_FILE,
+                "tasks": TASKS_FILE,
+                "code_gen_state": STATE_FILE,
+                "rpg_json": REPO_RPG_FILE,
+            },
+            verification=[
+                {"name": "result", "status": result.get("success", result.get("type"))},
+                {"name": "pytest", "status": result.get("passed", ""), "detail": f"failed={result.get('failed', '')}, errors={result.get('errors', '')}"},
+            ],
+            evidence={"result": result},
+        )
+        return str(report_path)
+    except Exception as exc:
+        result["report_error"] = str(exc)
+        return None
+
+
 def print_result(result: Dict[str, Any], json_output: bool = False) -> None:
     """Print result to stdout and log it."""
+    report_path = _write_batch_report(result)
+    if report_path:
+        result["report_path"] = report_path
+
     # Always log the result as JSON for the file log
     logger.info("Batch result: %s", json.dumps(result, indent=2))
 
@@ -962,6 +1008,9 @@ def print_result(result: Dict[str, Any], json_output: bool = False) -> None:
     if "next_action" in result:
         print(f"\n   ->  {result['next_action']}")
 
+    if result.get("report_path"):
+        print(f"\n   Report: {result['report_path']}")
+
 
 def main() -> int:
     # Convert SIGTERM → SystemExit so "except BaseException" in Popen calls
diff --git a/CoderMind/scripts/smoke_test.py b/CoderMind/scripts/smoke_test.py
index 71e9c4d..2f91e05 100644
--- a/CoderMind/scripts/smoke_test.py
+++ b/CoderMind/scripts/smoke_test.py
@@ -160,7 +160,13 @@ def _find_source_files(repo_path: Path) -> List[Path]:
 def _run_in_repo(repo_path: Path, cmd: List[str], timeout: int = 30) -> subprocess.CompletedProcess:
     """Run a command in the repo directory with the dev venv."""
     env = os.environ.copy()
-    env["PYTHONPATH"] = str(repo_path)
+    python_path = [str(repo_path)]
+    scripts_dir = repo_path / "scripts"
+    if scripts_dir.is_dir():
+        python_path.append(str(scripts_dir))
+    if env.get("PYTHONPATH"):
+        python_path.append(env["PYTHONPATH"])
+    env["PYTHONPATH"] = os.pathsep.join(python_path)
     # Suppress interactive prompts
     env["PYTHONDONTWRITEBYTECODE"] = "1"
     return subprocess.run(
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index b9964b3..4795423 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -34,6 +34,7 @@
 
 from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE, RPG_HTML_FILE, HOOK_CALLS_LOG  # noqa: E402
 from common.rpg_io import atomic_write_rpg, safe_load_rpg  # noqa: E402
+from common.run_report import write_command_report  # noqa: E402
 
 
 # Shared message used by every subcommand that requires an existing
@@ -79,6 +80,49 @@ def _log_hook_call(hook_type: str, result: dict) -> None:
         pass
 
 
+def _change_count(value: object) -> int:
+    if isinstance(value, int):
+        return value
+    if isinstance(value, (list, tuple, set, dict)):
+        return len(value)
+    return 0
+
+
+def _attach_update_report(result: dict) -> dict:
+    try:
+        changed_total = sum(
+            _change_count(result.get(key))
+            for key in ("modified", "added", "deleted", "renamed")
+        )
+        viz_status = result.get("viz_error") or ("ok" if result.get("viz_path") else "not recorded")
+        report_path = write_command_report(
+            "update_rpg",
+            title="CoderMind update_rpg Explain View",
+            status=result.get("mode") or result.get("status"),
+            summary_cards=[
+                {"label": "mode", "value": result.get("mode", "")},
+                {"label": "reason", "value": result.get("reason") or result.get("error", "")},
+                {"label": "changed files", "value": changed_total},
+                {"label": "RPG nodes", "value": result.get("rpg_nodes", "")},
+                {"label": "dep nodes", "value": result.get("dep_nodes", "")},
+                {"label": "dep edges", "value": result.get("dep_edges", "")},
+                {"label": "visualization", "value": result.get("viz_path") or result.get("viz_error", "")},
+            ],
+            stages=[
+                {"name": "git delta", "status": result.get("mode", ""), "reason": f"{changed_total} changed files"},
+                {"name": "sync graph", "status": result.get("status", result.get("mode", "")), "reason": result.get("reason", "")},
+                {"name": "visualize", "status": "ok" if result.get("viz_path") else "error" if result.get("viz_error") else "skipped", "reason": result.get("viz_path") or result.get("viz_error", "")},
+            ],
+            artifacts={"rpg_json": result.get("rpg_path"), "rpg_html": result.get("viz_path")},
+            verification={"update_rpg": result.get("status", result.get("mode")), "viz": viz_status},
+            evidence=result,
+        )
+        result["report_path"] = str(report_path)
+    except Exception as exc:
+        result["report_error"] = str(exc)
+    return result
+
+
 def _refresh_rpg_html(rpg_path: Path) -> dict:
     """Regenerate ``rpg.html`` next to ``rpg.json`` after a hook update.
 
@@ -364,12 +408,12 @@ def cmd_sync(
     # instead so the hook log shows exactly what's wrong and how to fix
     # it.
     if not rpg_path.is_file():
-        return {
+        return _attach_update_report({
             "mode": "sync",
             "error": _RPG_MISSING_MSG.format(rpg_path=rpg_path),
             "rpg_path": str(rpg_path),
             "duration": round(time.time() - t0, 3),
-        }
+        })
 
     svc = RPGService.load(str(rpg_path))
 
@@ -427,6 +471,7 @@ def cmd_sync(
         "viz_error": viz_result.get("viz_error"),
         "duration": round(time.time() - t0, 3),
     }
+    _attach_update_report(sync_out)
     _log_hook_call("sync", sync_out)
     return sync_out
 
@@ -458,11 +503,11 @@ def cmd_update_rpg(
     t0 = time.time()
 
     if not rpg_path.is_file():
-        return {
+        return _attach_update_report({
             "mode": "update-rpg",
             "error": _RPG_MISSING_MSG.format(rpg_path=rpg_path),
             "rpg_path": str(rpg_path),
-        }
+        })
 
     # Check git has enough history
     try:
@@ -472,10 +517,11 @@ def cmd_update_rpg(
             stderr=subprocess.DEVNULL,
         ).decode().strip()
     except (subprocess.CalledProcessError, FileNotFoundError):
-        return {
+        return _attach_update_report({
             "mode": "update-rpg",
             "error": "Need at least 2 commits for incremental update (no HEAD~1)",
-        }
+            "rpg_path": str(rpg_path),
+        })
 
     # Prune orphaned worktrees from previous runs that were killed.
     subprocess.call(
@@ -495,10 +541,12 @@ def cmd_update_rpg(
             text=True,
         )
         if wt_proc.returncode != 0:
-            return {
+            return _attach_update_report({
                 "mode": "update-rpg",
                 "error": f"git worktree add failed for {prev_ref}: {wt_proc.stderr.strip()}",
-            }
+                "rpg_path": str(rpg_path),
+                "prev_ref": prev_ref,
+            })
 
         from rpg_encoder.run_update_rpg import run_update_rpg
 
@@ -524,6 +572,7 @@ def cmd_update_rpg(
                 result["viz_error"] = viz_result["viz_error"]
 
         result["duration"] = round(time.time() - t0, 3)
+        _attach_update_report(result)
         _log_hook_call("update-rpg", result)
         return result
 
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
new file mode 100644
index 0000000..bdaab5a
--- /dev/null
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+_REPO = Path(__file__).resolve().parents[1]
+_SCRIPTS = _REPO / "scripts"
+if str(_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS))
+
+
+def _load_script(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_validate_and_locate_results_are_persisted(tmp_path: Path, monkeypatch) -> None:
+    validate = _load_script("rpg_edit_validate_test", _SCRIPTS / "rpg_edit" / "validate.py")
+    locate = _load_script("rpg_edit_locate_test", _SCRIPTS / "rpg_edit" / "locate.py")
+
+    validate_path = tmp_path / "rpg_edit_validate.json"
+    locate_path = tmp_path / "rpg_edit_locate.json"
+    monkeypatch.setattr(validate, "RPG_EDIT_VALIDATE_FILE", validate_path)
+    monkeypatch.setattr(locate, "RPG_EDIT_LOCATE_FILE", locate_path)
+
+    validate._write_validate_result({"type": "ready", "nodes": 2})
+    locate._write_locate_result({"type": "candidates", "results": [{"node_id": "n1"}]})
+
+    assert json.loads(validate_path.read_text(encoding="utf-8"))["type"] == "ready"
+    assert json.loads(locate_path.read_text(encoding="utf-8"))["results"][0]["node_id"] == "n1"
+
+
+def test_code_result_is_persisted(tmp_path: Path, monkeypatch) -> None:
+    code = _load_script("rpg_edit_code_test", _SCRIPTS / "rpg_edit" / "code.py")
+
+    result_path = tmp_path / "rpg_edit_code_result.json"
+    monkeypatch.setattr(code, "RPG_EDIT_CODE_RESULT_FILE", result_path)
+
+    code._write_code_result({"success": True, "commit_sha": "abc123"})
+
+    data = json.loads(result_path.read_text(encoding="utf-8"))
+    assert data == {"success": True, "commit_sha": "abc123"}
+
+
+def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch) -> None:
+    review = _load_script("rpg_edit_review_test", _SCRIPTS / "rpg_edit" / "review.py")
+
+    validate_path = tmp_path / "validate.json"
+    locate_path = tmp_path / "locate.json"
+    plan_path = tmp_path / "plan.json"
+    impact_path = tmp_path / "impact.json"
+    code_path = tmp_path / "code.json"
+    review_path = tmp_path / "review.json"
+    report_path = tmp_path / "report.html"
+
+    validate_path.write_text(json.dumps({"type": "ready"}), encoding="utf-8")
+    locate_path.write_text(json.dumps({"type": "candidates", "results": [{"node_id": "n1", "name": "Node", "score": 1.0, "dep_nodes": ["a.py:f"]}]}), encoding="utf-8")
+    plan_path.write_text(json.dumps({"affected_nodes": ["n1"], "code_changes": [{"file_path": "a.py"}]}), encoding="utf-8")
+    impact_path.write_text(json.dumps({"type": "impact", "results": {"n1": {}}}), encoding="utf-8")
+    code_path.write_text(json.dumps({"success": True, "files_modified": ["a.py"], "last_status": "complete"}), encoding="utf-8")
+
+    monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", validate_path)
+    monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
+    monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
+    monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
+
+    def fake_write_command_report(*args, **kwargs):
+        review_artifact = next(
+            item for item in kwargs["artifacts"] if item["label"] == "review_result"
+        )
+        assert review_artifact["status"] == "available"
+        return report_path
+
+    monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
+
+    result = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path)
+
+    assert result["report_path"] == str(report_path)
+    persisted = json.loads(review_path.read_text(encoding="utf-8"))
+    assert persisted["report_path"] == str(report_path)
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
new file mode 100644
index 0000000..7c89013
--- /dev/null
+++ b/CoderMind/tests/test_run_report.py
@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_REPO = Path(__file__).resolve().parents[1]
+_SCRIPTS = _REPO / "scripts"
+if str(_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS))
+
+from common.run_report import write_command_report
+
+
+def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path) -> None:
+    report = write_command_report(
+        "rpg/edit <script>alert(1)</script>",
+        title="Title <unsafe>",
+        status="ok <bad>",
+        summary_cards=[
+            {"label": "node", "value": "<script>alert(1)</script>"},
+            {"label": "count", "value": 3},
+        ],
+        stages=[{"name": "locate <x>", "status": "done", "reason": "score > 1"}],
+        rpg_nodes=[{"node_id": "feature<script>", "name": "Explain", "meta_path": "a.py"}],
+        dep_nodes=[{"node_id": "a.py:f", "path": "a.py"}],
+        artifacts={"plan": tmp_path / "plan.json"},
+        verification={"pytest": "passed"},
+        evidence={"raw": "<script>evil()</script>"},
+        report_dir=tmp_path,
+        timestamp="2026-06-30T12:34:56Z",
+    )
+
+    assert report.parent == tmp_path
+    assert report.name.startswith("cmind_run_rpg_edit_script_alert_1_script_")
+    html = report.read_text(encoding="utf-8")
+    assert "Summary" in html
+    assert "Stage timeline" in html
+    assert "Artifact links" in html
+    assert "Evidence JSON" in html
+    assert "&lt;script&gt;evil()&lt;/script&gt;" in html
+    assert "<script>alert(1)</script>" not in html
+
+
+def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
+    report = write_command_report(
+        "encode",
+        summary_cards=[{"label": f"card-{i}", "value": i} for i in range(9)],
+        report_dir=tmp_path,
+        timestamp="fixed",
+    )
+
+    html = report.read_text(encoding="utf-8")
+    assert html.count('class="card-label"') == 7
+    visible_cards = html.split("<section><details>", 1)[0]
+    assert "card-0" in visible_cards
+    assert "card-6" in visible_cards
+    assert "card-7" not in visible_cards
+    assert "card-8" not in visible_cards
+
+
+def test_write_command_report_preserves_same_timestamp_runs(tmp_path: Path) -> None:
+    first = write_command_report("update_rpg", report_dir=tmp_path, timestamp="fixed")
+    second = write_command_report("update_rpg", report_dir=tmp_path, timestamp="fixed")
+
+    assert first != second
+    assert first.name == "cmind_run_update_rpg_fixed.html"
+    assert second.name == "cmind_run_update_rpg_fixed_2.html"
+    assert first.exists()
+    assert second.exists()
+
+
+def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Path) -> None:
+    report = write_command_report(
+        "encode",
+        evidence={"dep_nodes": 4, "rpg_nodes": 6},
+        report_dir=tmp_path,
+        timestamp="fixed",
+    )
+
+    html = report.read_text(encoding="utf-8")
+    assert html.count("No node evidence recorded.") == 2
+    assert '"dep_nodes": 4' in html
+    assert '<td><code>4</code></td>' not in html

From 416764d2315b9c089c01b676c8198b002ed8c857 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Tue, 30 Jun 2026 10:54:10 +0000
Subject: [PATCH 02/56] fix(cmind): handle RPG updates from git subdirectory
 workspaces

Align update-rpg worktree comparisons and git diff outputs to the cmind workspace root so subdirectory workspaces do not duplicate RPG nodes.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/common/git_utils.py         | 36 +++++++-
 .../scripts/rpg_encoder/run_update_rpg.py     |  3 +-
 CoderMind/scripts/update_graphs.py            |  6 +-
 CoderMind/tests/test_encode_commands.py       | 51 +++++++++++
 .../tests/test_encoder_workspace_layout.py    | 91 +++++++++++++++++++
 CoderMind/tests/test_sync_from_commit_diff.py | 43 +++++++++
 6 files changed, 223 insertions(+), 7 deletions(-)

diff --git a/CoderMind/scripts/common/git_utils.py b/CoderMind/scripts/common/git_utils.py
index 3c72866..ebe40e3 100644
--- a/CoderMind/scripts/common/git_utils.py
+++ b/CoderMind/scripts/common/git_utils.py
@@ -565,6 +565,34 @@ def read_head(repo_dir: str | Path) -> Optional[dict]:
     }
 
 
+def git_workspace_prefix(workspace_dir: str | Path) -> str:
+    """Return the path from the git root to ``workspace_dir``.
+
+    Returns ``""`` when ``workspace_dir`` is the git root or when git metadata
+    cannot be read. This keeps callers safe outside git repositories.
+    """
+    if not workspace_dir:
+        return ""
+    workspace_path = Path(workspace_dir)
+    if not workspace_path.is_dir():
+        return ""
+
+    git_root = _run_git_readonly(
+        ["rev-parse", "--show-toplevel"],
+        workspace_path,
+    )
+    if not git_root:
+        return ""
+
+    try:
+        rel = workspace_path.resolve().relative_to(Path(git_root).resolve())
+    except ValueError:
+        return ""
+
+    rel_str = rel.as_posix()
+    return "" if rel_str == "." else rel_str
+
+
 # ---------------------------------------------------------------------------
 # Diff helpers — produce ``(modified, renames)`` from various git scopes.
 # ---------------------------------------------------------------------------
@@ -669,14 +697,14 @@ def staged_changes(
     if not repo_path.is_dir():
         return [], {}
     raw = _run_git_readonly(
-        ["diff", "--cached", "--name-status", "-M", "HEAD"],
+        ["diff", "--cached", "--relative", "--name-status", "-M", "HEAD"],
         repo_path,
     )
     if raw is None:
         # ``HEAD`` may not exist yet (unborn branch); try without it so
         # the very first commit's staged files still get picked up.
         raw = _run_git_readonly(
-            ["diff", "--cached", "--name-status", "-M"],
+            ["diff", "--cached", "--relative", "--name-status", "-M"],
             repo_path,
         )
     return _parse_name_status(raw)
@@ -706,7 +734,7 @@ def working_tree_changes(
         return [], {}
 
     raw = _run_git_readonly(
-        ["diff", "--name-status", "-M", "HEAD"],
+        ["diff", "--relative", "--name-status", "-M", "HEAD"],
         repo_path,
     )
     modified, renames = _parse_name_status(raw)
@@ -749,7 +777,7 @@ def changed_files_between(
     if not repo_path.is_dir():
         return [], {}
     raw = _run_git_readonly(
-        ["diff", "--name-status", "-M", f"{old_ref}..{new_ref}"],
+        ["diff", "--relative", "--name-status", "-M", f"{old_ref}..{new_ref}"],
         repo_path,
     )
     return _parse_name_status(raw)
diff --git a/CoderMind/scripts/rpg_encoder/run_update_rpg.py b/CoderMind/scripts/rpg_encoder/run_update_rpg.py
index c368ef4..bd2a9f6 100644
--- a/CoderMind/scripts/rpg_encoder/run_update_rpg.py
+++ b/CoderMind/scripts/rpg_encoder/run_update_rpg.py
@@ -228,8 +228,7 @@ def run_update_rpg(
         # to a full rebuild (rebase / diverged path).
         meta_git_advanced = False
         try:
-            ws_root = WORKSPACE_ROOT
-            current = read_head(ws_root)
+            current = read_head(cur_repo_dir)
             if current:
                 updated_rpg.set_git_meta(
                     head_commit=current["head_commit"],
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index 4795423..e017e4a 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -548,11 +548,15 @@ def cmd_update_rpg(
                 "prev_ref": prev_ref,
             })
 
+        from common.git_utils import git_workspace_prefix
         from rpg_encoder.run_update_rpg import run_update_rpg
 
+        git_prefix = git_workspace_prefix(workspace_root)
+        last_repo_dir = os.path.join(worktree_dir, git_prefix) if git_prefix else worktree_dir
+
         result = run_update_rpg(
             rpg_file=str(rpg_path),
-            last_repo_dir=worktree_dir,
+            last_repo_dir=last_repo_dir,
             cur_repo_dir=workspace_root,
             dep_graph_path=str(dep_graph_path),
         )
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 1e8b5db..2cb7c44 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -273,6 +273,57 @@ def test_missing_rpg_file(self, tmp_repo):
         assert result["status"] == "error"
         assert "not found" in result["error"]
 
+    def test_meta_git_reads_explicit_cur_repo_dir(self, tmp_path):
+        from rpg_encoder.run_update_rpg import run_update_rpg
+
+        last_repo = tmp_path / "last"
+        cur_repo = tmp_path / "current"
+        last_repo.mkdir()
+        cur_repo.mkdir()
+        rpg_file = tmp_path / "rpg.json"
+        rpg_file.write_text(json.dumps({
+            "repo_name": "test_repo",
+            "repo_info": "",
+            "root": {
+                "id": "test_repo_L0",
+                "name": "test_repo",
+                "node_type": "repo",
+                "level": 0,
+                "meta": {"type_name": "directory", "path": "."},
+                "children": [],
+            },
+            "edges": [],
+        }))
+
+        calls = []
+
+        def fake_read_head(repo_dir):
+            calls.append(Path(repo_dir))
+            return {
+                "head_commit": "a" * 40,
+                "head_short": "aaaaaaa",
+                "head_branch": "main",
+                "head_timestamp": "2026-06-30T00:00:00+00:00",
+            }
+
+        with patch(
+            "rpg_encoder.rpg_evolution.RPGEvolution.process_diff",
+            side_effect=lambda **kwargs: kwargs["last_rpg"],
+        ), patch(
+            "rpg.service.RPGService.enrich_from_code",
+            return_value={},
+        ), patch("common.git_utils.read_head", side_effect=fake_read_head):
+            result = run_update_rpg(
+                rpg_file=str(rpg_file),
+                last_repo_dir=str(last_repo),
+                cur_repo_dir=str(cur_repo),
+            )
+
+        assert result["status"] == "success"
+        assert result["meta_git_advanced"] is True
+        assert result["new_commit"] == "a" * 40
+        assert calls == [cur_repo.resolve()]
+
     def test_missing_last_repo_dir(self, tmp_rpg_file):
         """Should return error when last repo dir doesn't exist."""
         from rpg_encoder.run_update_rpg import run_update_rpg
diff --git a/CoderMind/tests/test_encoder_workspace_layout.py b/CoderMind/tests/test_encoder_workspace_layout.py
index 71a3ea7..7184cfe 100644
--- a/CoderMind/tests/test_encoder_workspace_layout.py
+++ b/CoderMind/tests/test_encoder_workspace_layout.py
@@ -18,6 +18,7 @@
 
 import importlib
 import os
+import subprocess
 import sys
 from pathlib import Path
 
@@ -31,6 +32,10 @@
 # Fixtures — reload ``common.paths`` against an arbitrary workspace
 # ---------------------------------------------------------------------------
 
+def _git(cwd: Path, *args: str) -> None:
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
+
+
 def _reload_paths_against(workspace: Path):
     """Import / reload ``common.paths`` with ``workspace`` as cwd.
 
@@ -77,6 +82,30 @@ def workspace_with_repo_subdir(tmp_path, monkeypatch):
     return ws
 
 
+@pytest.fixture
+def workspace_inside_git_repo(tmp_path, monkeypatch):
+    git_root = tmp_path / "gitroot"
+    workspace = git_root / "subproject"
+    src = workspace / "src"
+    src.mkdir(parents=True)
+    (workspace / ".cmind").mkdir()
+    (src / "module.py").write_text("def value():\n    return 1\n")
+
+    _git(git_root, "init", "-q", "-b", "main")
+    _git(git_root, "config", "user.email", "test@example.com")
+    _git(git_root, "config", "user.name", "Test User")
+    _git(git_root, "add", ".")
+    _git(git_root, "commit", "-q", "-m", "initial")
+
+    (src / "module.py").write_text("def value():\n    return 2\n")
+    _git(git_root, "add", ".")
+    _git(git_root, "commit", "-q", "-m", "update module")
+
+    monkeypatch.chdir(workspace)
+    monkeypatch.delenv("CMIND_WORKSPACE", raising=False)
+    return git_root, workspace
+
+
 # ---------------------------------------------------------------------------
 # Encoder entry point defaults
 # ---------------------------------------------------------------------------
@@ -229,3 +258,65 @@ def test_update_graphs_auto_detect_ignores_present_repo_subdir(
     assert result == str(workspace_with_repo_subdir)
     # Critically NOT the repo/ subdir
     assert result != str(workspace_with_repo_subdir / "repo")
+
+
+def test_git_workspace_prefix_handles_workspace_inside_git_repo(
+    workspace_inside_git_repo,
+):
+    git_root, workspace = workspace_inside_git_repo
+    _reload_paths_against(workspace)
+    from common.git_utils import git_workspace_prefix
+
+    assert git_workspace_prefix(workspace) == "subproject"
+    assert git_workspace_prefix(git_root) == ""
+
+
+def test_cmd_update_rpg_passes_subdir_adjusted_last_repo_dir(
+    workspace_inside_git_repo,
+    monkeypatch,
+):
+    _, workspace = workspace_inside_git_repo
+    _reload_paths_against(workspace)
+
+    import update_graphs
+    importlib.reload(update_graphs)
+    import rpg_encoder.run_update_rpg as run_update_mod
+
+    data_dir = workspace / ".cmind" / "data"
+    data_dir.mkdir(parents=True)
+    rpg_path = data_dir / "rpg.json"
+    dep_graph_path = data_dir / "dep_graph.json"
+    rpg_path.write_text("{}")
+
+    captured = {}
+
+    def fake_run_update_rpg(*, rpg_file, last_repo_dir, cur_repo_dir, dep_graph_path):
+        last_repo = Path(last_repo_dir)
+        captured["rpg_file"] = rpg_file
+        captured["last_repo_dir"] = last_repo.as_posix()
+        captured["cur_repo_dir"] = cur_repo_dir
+        captured["dep_graph_path"] = dep_graph_path
+        captured["old_file_at_workspace_root"] = (
+            last_repo / "src" / "module.py"
+        ).is_file()
+        captured["nested_subproject_exists"] = (
+            last_repo / "subproject"
+        ).exists()
+        return {"status": "success", "repo_name": "subproject"}
+
+    monkeypatch.setattr(run_update_mod, "run_update_rpg", fake_run_update_rpg)
+    monkeypatch.setattr(update_graphs, "_refresh_rpg_html", lambda _rpg_path: {})
+    monkeypatch.setattr(update_graphs, "_attach_update_report", lambda result: result)
+    monkeypatch.setattr(update_graphs, "_log_hook_call", lambda *_args, **_kwargs: None)
+
+    result = update_graphs.cmd_update_rpg(
+        rpg_path=rpg_path,
+        dep_graph_path=dep_graph_path,
+        workspace_root=str(workspace),
+    )
+
+    assert result["status"] == "success"
+    assert captured["last_repo_dir"].endswith("/subproject")
+    assert captured["cur_repo_dir"] == str(workspace)
+    assert captured["old_file_at_workspace_root"] is True
+    assert captured["nested_subproject_exists"] is False
diff --git a/CoderMind/tests/test_sync_from_commit_diff.py b/CoderMind/tests/test_sync_from_commit_diff.py
index 023d18c..fcef438 100644
--- a/CoderMind/tests/test_sync_from_commit_diff.py
+++ b/CoderMind/tests/test_sync_from_commit_diff.py
@@ -129,6 +129,49 @@ def _node_edge_snapshot(g: DependencyGraph) -> Tuple[Dict[str, dict], Set[Tuple[
     return nodes, edges
 
 
+def test_git_diff_helpers_return_workspace_relative_paths_in_subdir(tmp_path):
+    from common.git_utils import (
+        changed_files_between,
+        staged_changes,
+        working_tree_changes,
+    )
+
+    git_root = tmp_path / "gitroot"
+    workspace = git_root / "subproject"
+    src = workspace / "src"
+    src.mkdir(parents=True)
+    (src / "a.py").write_text("def a():\n    return 1\n")
+
+    _sh(git_root, "init", "-q", "-b", "main")
+    _sh(git_root, "config", "user.email", "test@example.com")
+    _sh(git_root, "config", "user.name", "Test")
+    _sh(git_root, "add", ".")
+    _sh(git_root, "commit", "-q", "-m", "initial")
+    first = _head_sha(git_root)
+
+    (src / "a.py").write_text("def a():\n    return 2\n")
+    _sh(git_root, "add", ".")
+    _sh(git_root, "commit", "-q", "-m", "update a")
+    second = _head_sha(git_root)
+
+    changed, renames = changed_files_between(workspace, first, second)
+    assert changed == ["src/a.py"]
+    assert renames == {}
+
+    (src / "a.py").write_text("def a():\n    return 3\n")
+    _sh(git_root, "add", "subproject/src/a.py")
+    changed, renames = staged_changes(workspace)
+    assert changed == ["src/a.py"]
+    assert renames == {}
+
+    (src / "new.py").write_text("def new():\n    return 1\n")
+    changed, renames = working_tree_changes(workspace)
+    assert "src/a.py" in changed
+    assert "src/new.py" in changed
+    assert all(not path.startswith("subproject/") for path in changed)
+    assert renames == {}
+
+
 # ---------------------------------------------------------------------------
 # Decision tree
 # ---------------------------------------------------------------------------

From 2b443e9b86e7daf69e3b486de9f0ff6203a6f662 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 04:34:17 +0000
Subject: [PATCH 03/56] fix(cmind): correct update_rpg report delta reporting

Report update_rpg results using the actual output fields, include raw git delta counts, and propagate semantic diff summaries so Explain View no longer shows zero/empty values for changed files and graph node counts.
---
 .../scripts/rpg_encoder/rpg_evolution.py      |  32 +++-
 .../scripts/rpg_encoder/run_update_rpg.py     |   6 +
 CoderMind/scripts/update_graphs.py            | 155 ++++++++++++++++--
 CoderMind/tests/test_encode_commands.py       |  97 +++++++++++
 CoderMind/tests/test_rpg_evolution.py         |   9 +-
 5 files changed, 277 insertions(+), 22 deletions(-)

diff --git a/CoderMind/scripts/rpg_encoder/rpg_evolution.py b/CoderMind/scripts/rpg_encoder/rpg_evolution.py
index 5b9507e..18c483b 100644
--- a/CoderMind/scripts/rpg_encoder/rpg_evolution.py
+++ b/CoderMind/scripts/rpg_encoder/rpg_evolution.py
@@ -758,6 +758,18 @@ def process_diff(
                     save_path=dep_graph_save_path,
                 )
 
+            last_rpg._last_diff_summary = {
+                "added": 0,
+                "deleted": 0,
+                "modified": 0,
+                "renamed": 0,
+            }
+            last_rpg._last_diff_files = {
+                "added": [],
+                "deleted": [],
+                "modified": [],
+                "renamed": [],
+            }
             total_time = time.time() - global_start
             logger.info(
                 "\nNo changes detected for [%s]. RPG remains unchanged.\n"
@@ -795,6 +807,20 @@ def process_diff(
                 save_path=dep_graph_save_path,
             )
 
+        diff_summary = {
+            "added": len(add_files),
+            "deleted": len(deleted_files),
+            "modified": len(modified_result),
+            "renamed": 0,
+        }
+        ctx["last_rpg"]._last_diff_summary = diff_summary
+        ctx["last_rpg"]._last_diff_files = {
+            "added": add_files,
+            "deleted": deleted_files,
+            "modified": list(modified_result.keys()),
+            "renamed": [],
+        }
+
         # Save results
         result = {
             "repo_name": repo_name,
@@ -804,11 +830,7 @@ def process_diff(
                 "structure": ctx["last_rpg"].to_dict(),
                 "feature_tree": ctx["last_rpg"].get_functionality_graph(),
             },
-            "diff_summary": {
-                "added": len(add_files),
-                "deleted": len(deleted_files),
-                "modified": len(modified_result),
-            },
+            "diff_summary": diff_summary,
         }
 
         if save_path:
diff --git a/CoderMind/scripts/rpg_encoder/run_update_rpg.py b/CoderMind/scripts/rpg_encoder/run_update_rpg.py
index bd2a9f6..d62f7e0 100644
--- a/CoderMind/scripts/rpg_encoder/run_update_rpg.py
+++ b/CoderMind/scripts/rpg_encoder/run_update_rpg.py
@@ -253,6 +253,8 @@ def run_update_rpg(
         post_nodes = len(updated_rpg.nodes)
         post_edges = _serialized_feature_edges(result_data)
         post_dep_stats = _serialized_dep_stats(result_data)
+        diff_summary = getattr(updated_rpg, "_last_diff_summary", None)
+        diff_files = getattr(updated_rpg, "_last_diff_files", None)
 
         stats = {
             "repo_name": repo_name,
@@ -274,6 +276,10 @@ def run_update_rpg(
             "previous_commit": pre_commit,
             "new_commit": (updated_rpg.git_meta or {}).get("head_commit"),
         }
+        if isinstance(diff_summary, dict):
+            stats["diff_summary"] = diff_summary
+        if isinstance(diff_files, dict):
+            stats["diff_files"] = diff_files
         try:
             stats["functional_areas"] = len(updated_rpg.get_functional_areas())
         except Exception:
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index e017e4a..605e798 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -88,33 +88,150 @@ def _change_count(value: object) -> int:
     return 0
 
 
+def _diff_summary(result: dict) -> dict:
+    summary = result.get("diff_summary")
+    if isinstance(summary, dict):
+        return {
+            "added": _change_count(summary.get("added")),
+            "deleted": _change_count(summary.get("deleted")),
+            "modified": _change_count(summary.get("modified")),
+            "renamed": _change_count(summary.get("renamed")),
+        }
+    return {
+        key: _change_count(result.get(key))
+        for key in ("added", "deleted", "modified", "renamed")
+    }
+
+
+def _format_count_delta(value: object, delta: object) -> object:
+    if value in (None, ""):
+        return ""
+    if isinstance(delta, int):
+        return f"{value} (delta: {delta:+d})"
+    return value
+
+
+def _format_diff_summary(summary: dict) -> str:
+    total = sum(summary.values())
+    parts = [f"{total} semantic files"]
+    for key in ("added", "deleted", "modified", "renamed"):
+        count = summary.get(key, 0)
+        if count:
+            parts.append(f"{key}={count}")
+    return ", ".join(parts)
+
+
+def _git_delta_files(prev_ref: str, workspace_root: str) -> list[dict[str, str]]:
+    import subprocess
+
+    try:
+        output = subprocess.check_output(
+            ["git", "diff", "--name-status", f"{prev_ref}..HEAD", "--", "."],
+            cwd=workspace_root,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return []
+    files: list[dict[str, str]] = []
+    for line in output.splitlines():
+        parts = line.split("\t")
+        if len(parts) >= 2:
+            files.append({"status": parts[0], "path": parts[-1]})
+    return files
+
+
 def _attach_update_report(result: dict) -> dict:
     try:
-        changed_total = sum(
-            _change_count(result.get(key))
-            for key in ("modified", "added", "deleted", "renamed")
+        semantic_summary = _diff_summary(result)
+        semantic_total = sum(semantic_summary.values())
+        git_delta = result.get("git_delta")
+        git_total = _change_count(git_delta) if git_delta is not None else ""
+        node_count = result.get("node_count", result.get("rpg_nodes", ""))
+        rpg_path = result.get("output_path") or result.get("rpg_path")
+        dep_summary = ""
+        if result.get("dep_nodes") not in (None, ""):
+            dep_summary = "nodes={}".format(
+                _format_count_delta(
+                    result.get("dep_nodes"),
+                    result.get("dep_nodes_delta"),
+                )
+            )
+            if result.get("dep_edges") not in (None, ""):
+                dep_summary += ", edges={}".format(
+                    _format_count_delta(
+                        result.get("dep_edges"),
+                        result.get("dep_edges_delta"),
+                    )
+                )
+        viz_status = result.get("viz_error") or (
+            "ok" if result.get("viz_path") else "not recorded"
         )
-        viz_status = result.get("viz_error") or ("ok" if result.get("viz_path") else "not recorded")
         report_path = write_command_report(
             "update_rpg",
             title="CoderMind update_rpg Explain View",
             status=result.get("mode") or result.get("status"),
             summary_cards=[
                 {"label": "mode", "value": result.get("mode", "")},
-                {"label": "reason", "value": result.get("reason") or result.get("error", "")},
-                {"label": "changed files", "value": changed_total},
-                {"label": "RPG nodes", "value": result.get("rpg_nodes", "")},
-                {"label": "dep nodes", "value": result.get("dep_nodes", "")},
-                {"label": "dep edges", "value": result.get("dep_edges", "")},
-                {"label": "visualization", "value": result.get("viz_path") or result.get("viz_error", "")},
+                {
+                    "label": "reason",
+                    "value": result.get("reason") or result.get("error", ""),
+                },
+                {"label": "git files", "value": git_total},
+                {"label": "semantic files", "value": semantic_total},
+                {
+                    "label": "RPG nodes",
+                    "value": _format_count_delta(
+                        node_count,
+                        result.get("nodes_delta"),
+                    ),
+                },
+                {"label": "dep graph", "value": dep_summary},
+                {
+                    "label": "visualization",
+                    "value": result.get("viz_path") or result.get("viz_error", ""),
+                },
             ],
             stages=[
-                {"name": "git delta", "status": result.get("mode", ""), "reason": f"{changed_total} changed files"},
-                {"name": "sync graph", "status": result.get("status", result.get("mode", "")), "reason": result.get("reason", "")},
-                {"name": "visualize", "status": "ok" if result.get("viz_path") else "error" if result.get("viz_error") else "skipped", "reason": result.get("viz_path") or result.get("viz_error", "")},
+                {
+                    "name": "git delta",
+                    "status": result.get("mode", ""),
+                    "reason": (
+                        f"{git_total} changed files"
+                        if git_total != ""
+                        else "not recorded"
+                    ),
+                },
+                {
+                    "name": "semantic delta",
+                    "status": result.get("mode", ""),
+                    "reason": _format_diff_summary(semantic_summary),
+                },
+                {
+                    "name": "sync graph",
+                    "status": result.get("status", result.get("mode", "")),
+                    "reason": result.get("reason", ""),
+                },
+                {
+                    "name": "visualize",
+                    "status": (
+                        "ok"
+                        if result.get("viz_path")
+                        else "error"
+                        if result.get("viz_error")
+                        else "skipped"
+                    ),
+                    "reason": result.get("viz_path") or result.get("viz_error", ""),
+                },
             ],
-            artifacts={"rpg_json": result.get("rpg_path"), "rpg_html": result.get("viz_path")},
-            verification={"update_rpg": result.get("status", result.get("mode")), "viz": viz_status},
+            artifacts={
+                "rpg_json": rpg_path,
+                "rpg_html": result.get("viz_path"),
+            },
+            verification={
+                "update_rpg": result.get("status", result.get("mode")),
+                "viz": viz_status,
+            },
             evidence=result,
         )
         result["report_path"] = str(report_path)
@@ -552,7 +669,12 @@ def cmd_update_rpg(
         from rpg_encoder.run_update_rpg import run_update_rpg
 
         git_prefix = git_workspace_prefix(workspace_root)
-        last_repo_dir = os.path.join(worktree_dir, git_prefix) if git_prefix else worktree_dir
+        last_repo_dir = (
+            os.path.join(worktree_dir, git_prefix)
+            if git_prefix
+            else worktree_dir
+        )
+        git_delta = _git_delta_files(prev_ref, workspace_root)
 
         result = run_update_rpg(
             rpg_file=str(rpg_path),
@@ -563,6 +685,7 @@ def cmd_update_rpg(
 
         result["mode"] = "update-rpg"
         result["prev_ref"] = prev_ref
+        result["git_delta"] = git_delta
 
         # Refresh ``rpg.html`` whenever the JSON was actually rewritten.
         # ``run_update_rpg`` returns ``status="success"`` on a normal
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 2cb7c44..4014e39 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -324,6 +324,52 @@ def fake_read_head(repo_dir):
         assert result["new_commit"] == "a" * 40
         assert calls == [cur_repo.resolve()]
 
+    def test_diff_summary_is_returned(self, tmp_rpg_file, tmp_path):
+        from rpg_encoder.run_update_rpg import run_update_rpg
+
+        last_repo = tmp_path / "last"
+        cur_repo = tmp_path / "current"
+        last_repo.mkdir()
+        cur_repo.mkdir()
+
+        def fake_process_diff(**kwargs):
+            rpg = kwargs["last_rpg"]
+            rpg._last_diff_summary = {
+                "added": 1,
+                "deleted": 0,
+                "modified": 2,
+                "renamed": 0,
+            }
+            rpg._last_diff_files = {
+                "added": ["a.py"],
+                "deleted": [],
+                "modified": ["b.py", "c.py"],
+                "renamed": [],
+            }
+            return rpg
+
+        with patch(
+            "rpg_encoder.rpg_evolution.RPGEvolution.process_diff",
+            side_effect=fake_process_diff,
+        ), patch(
+            "rpg.service.RPGService.enrich_from_code",
+            return_value={},
+        ), patch("common.git_utils.read_head", return_value=None):
+            result = run_update_rpg(
+                rpg_file=tmp_rpg_file,
+                last_repo_dir=str(last_repo),
+                cur_repo_dir=str(cur_repo),
+            )
+
+        assert result["status"] == "success"
+        assert result["diff_summary"] == {
+            "added": 1,
+            "deleted": 0,
+            "modified": 2,
+            "renamed": 0,
+        }
+        assert result["diff_files"]["modified"] == ["b.py", "c.py"]
+
     def test_missing_last_repo_dir(self, tmp_rpg_file):
         """Should return error when last repo dir doesn't exist."""
         from rpg_encoder.run_update_rpg import run_update_rpg
@@ -346,6 +392,57 @@ def test_missing_cur_repo_dir(self, tmp_rpg_file):
         assert "not found" in result["error"]
 
 
+# ============================================================================
+# Test: update_graphs report wiring
+# ============================================================================
+
+
+def test_attach_update_report_uses_update_rpg_result_fields(tmp_path, monkeypatch):
+    import update_graphs
+
+    captured = {}
+
+    def fake_write_command_report(command, **kwargs):
+        captured["command"] = command
+        captured.update(kwargs)
+        return tmp_path / "report.html"
+
+    monkeypatch.setattr(update_graphs, "write_command_report", fake_write_command_report)
+
+    result = update_graphs._attach_update_report({
+        "mode": "update-rpg",
+        "status": "success",
+        "output_path": "/tmp/rpg.json",
+        "node_count": 4504,
+        "nodes_delta": 2,
+        "dep_nodes": 2708,
+        "dep_nodes_delta": 46,
+        "dep_edges": 5498,
+        "dep_edges_delta": 103,
+        "diff_summary": {
+            "added": 0,
+            "deleted": 0,
+            "modified": 3,
+            "renamed": 0,
+        },
+        "git_delta": [
+            {"status": "M", "path": "scripts/a.py"},
+            {"status": "M", "path": "tests/test_a.py"},
+        ],
+        "viz_path": "/tmp/rpg.html",
+    })
+
+    cards = {card["label"]: card["value"] for card in captured["summary_cards"]}
+    assert result["report_path"] == str(tmp_path / "report.html")
+    assert cards["git files"] == 2
+    assert cards["semantic files"] == 3
+    assert cards["RPG nodes"] == "4504 (delta: +2)"
+    assert cards["dep graph"] == "nodes=2708 (delta: +46), edges=5498 (delta: +103)"
+    assert captured["artifacts"]["rpg_json"] == "/tmp/rpg.json"
+    assert captured["stages"][0]["reason"] == "2 changed files"
+    assert captured["stages"][1]["reason"] == "3 semantic files, modified=3"
+
+
 # ============================================================================
 # Test: Template validation
 # ============================================================================
diff --git a/CoderMind/tests/test_rpg_evolution.py b/CoderMind/tests/test_rpg_evolution.py
index 4f72b4b..e9bb59c 100644
--- a/CoderMind/tests/test_rpg_evolution.py
+++ b/CoderMind/tests/test_rpg_evolution.py
@@ -745,7 +745,7 @@ def test_save_path_creates_file(self, simple_rpg):
                      return_value=diff_result,
                  ):
 
-                RPGEvolution.process_diff(
+                updated_rpg = RPGEvolution.process_diff(
                     repo_name="test",
                     repo_info="Test repo",
                     save_path=save_path,
@@ -756,6 +756,13 @@ def test_save_path_creates_file(self, simple_rpg):
                     update_dep_graph=False,
                 )
 
+                assert updated_rpg._last_diff_summary == {
+                    "added": 0,
+                    "deleted": 1,
+                    "modified": 0,
+                    "renamed": 0,
+                }
+                assert updated_rpg._last_diff_files["deleted"] == ["src/module_a.py"]
                 assert os.path.isfile(save_path)
                 with open(save_path, "r") as f:
                     data = json.load(f)

From f6b79a61592ce89fc46fbb80960d003e74d332f0 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 04:54:46 +0000
Subject: [PATCH 04/56] Update .gitignore.

---
 CoderMind/.gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CoderMind/.gitignore b/CoderMind/.gitignore
index 835fb40..298698b 100644
--- a/CoderMind/.gitignore
+++ b/CoderMind/.gitignore
@@ -239,3 +239,5 @@ plans/
 .mcp.json
 .github/agents/
 .github/prompts/
+
+.claude/commands/

From 9c2db7d8ef7257a4a0ec2a93dffbed7b49b76a37 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 05:04:41 +0000
Subject: [PATCH 05/56] rpg_edit: At _normalize_artifacts() lines 224-240 and
 _render_artifact

---
 CoderMind/scripts/common/run_report.py      | 30 +++++++++++++---
 CoderMind/scripts/rpg_edit/review.py        | 39 ++++++++++++++++----
 CoderMind/tests/test_rpg_edit_run_report.py | 40 +++++++++++++++++++++
 CoderMind/tests/test_run_report.py          | 25 +++++++++++++
 4 files changed, 123 insertions(+), 11 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index f100477..9c03284 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -230,16 +230,36 @@ def _normalize_artifacts(value: Any) -> list[dict[str, Any]]:
     for item in iterable:
         if isinstance(item, tuple) and len(item) == 2:
             label, path = item
-            artifacts.append({"label": label, "path": path})
+            artifacts.append({"label": label, "path": path, "status": _artifact_status(path)})
         elif isinstance(item, Mapping):
             path = item.get("path") or item.get("href") or item.get("url") or item.get("file")
-            label = item.get("label") or item.get("name") or item.get("title") or path or "artifact"
-            artifacts.append({"label": label, "path": path, "status": item.get("status")})
+            label = item.get("label") or item.get("name") or item.get("title")
+            if path is None:
+                path_items = [
+                    (key, item_value)
+                    for key, item_value in item.items()
+                    if key not in {"label", "name", "title", "status"}
+                ]
+                if len(path_items) == 1:
+                    label, path = path_items[0]
+            label = label or path or "artifact"
+            artifacts.append({"label": label, "path": path, "status": _artifact_status(path, item.get("status"))})
         else:
-            artifacts.append({"label": Path(str(item)).name or "artifact", "path": item})
+            artifacts.append({"label": Path(str(item)).name or "artifact", "path": item, "status": _artifact_status(item)})
     return artifacts
 
 
+def _artifact_status(path: Any, status: Any = None) -> Any:
+    if status not in (None, ""):
+        return status
+    if path in (None, ""):
+        return "missing"
+    try:
+        return "available" if Path(str(path)).expanduser().exists() else "missing"
+    except (OSError, ValueError):
+        return "missing"
+
+
 def _normalize_verification(value: Any) -> list[dict[str, Any]]:
     checks: list[dict[str, Any]] = []
     if isinstance(value, Mapping) and not any(isinstance(v, Mapping) for v in value.values()):
@@ -433,7 +453,7 @@ def _render_artifacts(artifacts: list[dict[str, Any]]) -> str:
                 "<tr>"
                 f"<td>{_h(artifact.get('label', 'artifact'))}</td>"
                 f"<td><a href=\"{_h_attr(href)}\">{_h(path or '')}</a></td>"
-                f"<td>{_h(artifact.get('status', ''))}</td>"
+                f"<td>{_h(_artifact_status(path, artifact.get('status')))}</td>"
                 "</tr>"
             )
         body = "<table><thead><tr><th>Artifact</th><th>Path</th><th>Status</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 45af3ce..9b4efc9 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -94,14 +94,41 @@ def _artifact_links(plan_path: Path, impact_path: Optional[Path]) -> List[Dict[s
     return links
 
 
+def _impact_results(artifacts: Dict[str, Any]) -> Dict[str, Any]:
+    impact = artifacts.get("impact") if isinstance(artifacts.get("impact"), dict) else {}
+    results = impact.get("results") if isinstance(impact.get("results"), dict) else {}
+    return results
+
+
 def _selected_candidate_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
     locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
     plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
-    affected = set(plan.get("affected_nodes") or [])
-    candidates = locate.get("results") or []
-    if affected:
-        candidates = [c for c in candidates if c.get("node_id") in affected]
-    return [c for c in candidates if isinstance(c, dict)]
+    affected = [node_id for node_id in plan.get("affected_nodes") or [] if node_id]
+    candidates = [c for c in locate.get("results") or [] if isinstance(c, dict)]
+    if not affected:
+        return candidates
+
+    impact_results = _impact_results(artifacts)
+    candidates_by_id = {c.get("node_id"): c for c in candidates if c.get("node_id") in affected}
+    rows: List[Dict[str, Any]] = []
+    for node_id in affected:
+        impact = impact_results.get(node_id) if isinstance(impact_results.get(node_id), dict) else {}
+        candidate = dict(candidates_by_id.get(node_id) or {"node_id": node_id})
+        if impact:
+            candidate.setdefault("name", impact.get("name", ""))
+            if not candidate.get("dep_nodes"):
+                candidate["dep_nodes"] = impact.get("dep_nodes") or []
+            if not candidate.get("status") and (impact.get("error") or impact.get("message")):
+                candidate["status"] = impact.get("error") or impact.get("message")
+        rows.append(candidate)
+    return rows
+
+
+def _dep_node_path(dep_id: Any) -> str:
+    if dep_id in (None, ""):
+        return ""
+    dep_id_text = str(dep_id)
+    return dep_id_text.split(":", 1)[0] if ":" in dep_id_text else dep_id_text
 
 
 def _dep_node_rows(candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -111,7 +138,7 @@ def _dep_node_rows(candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
             rows.append({
                 "node_id": dep_id,
                 "source_feature": candidate.get("node_id"),
-                "path": candidate.get("meta_path"),
+                "path": _dep_node_path(dep_id) or candidate.get("meta_path"),
             })
     return rows
 
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index bdaab5a..257cd10 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -84,3 +84,43 @@ def fake_write_command_report(*args, **kwargs):
     assert result["report_path"] == str(report_path)
     persisted = json.loads(review_path.read_text(encoding="utf-8"))
     assert persisted["report_path"] == str(report_path)
+
+
+def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path: Path, monkeypatch) -> None:
+    review = _load_script("rpg_edit_review_impact_test", _SCRIPTS / "rpg_edit" / "review.py")
+
+    validate_path = tmp_path / "validate.json"
+    locate_path = tmp_path / "locate.json"
+    plan_path = tmp_path / "plan.json"
+    impact_path = tmp_path / "impact.json"
+    code_path = tmp_path / "code.json"
+    review_path = tmp_path / "review.json"
+    report_path = tmp_path / "report.html"
+    dep_id = "scripts/common/run_report.py:_render_artifacts"
+
+    validate_path.write_text(json.dumps({"type": "ready"}), encoding="utf-8")
+    locate_path.write_text(json.dumps({"type": "candidates", "results": [{"node_id": "other", "name": "Other"}]}), encoding="utf-8")
+    plan_path.write_text(json.dumps({"affected_nodes": ["planned"], "code_changes": [{"file_path": "scripts/common/run_report.py"}]}), encoding="utf-8")
+    impact_path.write_text(
+        json.dumps({"type": "impact", "results": {"planned": {"name": "Planned Node", "dep_nodes": [dep_id], "affected_files": ["scripts/common/run_report.py"]}}}),
+        encoding="utf-8",
+    )
+    code_path.write_text(json.dumps({"success": True, "files_modified": ["scripts/common/run_report.py"], "last_status": "complete"}), encoding="utf-8")
+
+    monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", validate_path)
+    monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
+    monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
+    monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
+
+    def fake_write_command_report(*args, **kwargs):
+        assert kwargs["rpg_nodes"] == [{"node_id": "planned", "name": "Planned Node", "dep_nodes": [dep_id]}]
+        assert kwargs["dep_nodes"] == [
+            {"node_id": dep_id, "source_feature": "planned", "path": "scripts/common/run_report.py"}
+        ]
+        return report_path
+
+    monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
+
+    result = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path)
+
+    assert result["report_path"] == str(report_path)
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 7c89013..6fef570 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -81,3 +81,28 @@ def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Pa
     assert html.count("No node evidence recorded.") == 2
     assert '"dep_nodes": 4' in html
     assert '<td><code>4</code></td>' not in html
+
+
+def test_write_command_report_infers_artifact_status_and_preserves_verification_detail(tmp_path: Path) -> None:
+    available = tmp_path / "available.json"
+    available.write_text("{}", encoding="utf-8")
+    missing = tmp_path / "missing.json"
+
+    report = write_command_report(
+        "encode",
+        artifacts=[("rpg_json", available), {"missing_json": missing}],
+        verification=[
+            {"name": "message", "status": "ok", "message": "from message"},
+            {"name": "reason", "status": "warn", "reason": "from reason"},
+        ],
+        report_dir=tmp_path,
+        timestamp="fixed",
+    )
+
+    html = report.read_text(encoding="utf-8")
+    assert "<td>rpg_json</td>" in html
+    assert "<td>missing_json</td>" in html
+    assert html.count("<td>available</td>") == 1
+    assert html.count("<td>missing</td>") == 1
+    assert "<td>from message</td>" in html
+    assert "<td>from reason</td>" in html

From fd5a29c82d8c8c158d1d76b400a07a39350b0b45 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 05:19:52 +0000
Subject: [PATCH 06/56] fix(cmind): clear smoke test baseline failures

Use package-aware imports for llm_usage_count_coarse and make intentional no-op/unsupported backend methods explicit so smoke stub detection no longer flags valid code.
---
 CoderMind/scripts/common/session_manager.py   |  2 +-
 CoderMind/scripts/common/utils.py             |  3 ---
 .../scripts/decoder_lang/python_backend.py    |  6 ++++++
 .../utils/claude/llm_usage_count_coarse.py    | 20 ++++++++++++++-----
 4 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/CoderMind/scripts/common/session_manager.py b/CoderMind/scripts/common/session_manager.py
index df8fd5a..daa0a23 100644
--- a/CoderMind/scripts/common/session_manager.py
+++ b/CoderMind/scripts/common/session_manager.py
@@ -225,7 +225,7 @@ class NullSessionManager(SessionManager):
     """
 
     def before(self, ctx: TraceContext, prompt: str) -> None:
-        pass
+        return None
 
     def after(self, purpose: str) -> Optional[Path]:
         return None
diff --git a/CoderMind/scripts/common/utils.py b/CoderMind/scripts/common/utils.py
index 1dd1874..a4f3809 100644
--- a/CoderMind/scripts/common/utils.py
+++ b/CoderMind/scripts/common/utils.py
@@ -857,9 +857,6 @@ def get_skeleton(
     class _CompressTransformer(cst.CSTTransformer):
         """Replace function bodies with ``...`` while preserving structure."""
 
-        def __init__(self):
-            pass
-
         def _is_import_stmt(self, stmt: cst.CSTNode) -> bool:
             if not m.matches(stmt, m.SimpleStatementLine()):
                 return False
diff --git a/CoderMind/scripts/decoder_lang/python_backend.py b/CoderMind/scripts/decoder_lang/python_backend.py
index 06384dd..b329e42 100644
--- a/CoderMind/scripts/decoder_lang/python_backend.py
+++ b/CoderMind/scripts/decoder_lang/python_backend.py
@@ -14,6 +14,7 @@
 import ast
 import keyword
 import logging
+from abc import abstractmethod
 from pathlib import Path
 from typing import Any
 
@@ -422,6 +423,7 @@ def _source_for_node(source: str, node: ast.AST) -> str:
     # 3. Build / test environment — not wired into the decoder yet
     # ------------------------------------------------------------------
 
+    @abstractmethod
     def detect_env(self, repo_root: Path) -> EnvHandle | None:
         """Return an existing Python test environment when supported."""
         raise NotImplementedError(
@@ -430,6 +432,7 @@ def detect_env(self, repo_root: Path) -> EnvHandle | None:
             "for now.",
         )
 
+    @abstractmethod
     def ensure_env(self, repo_root: Path) -> EnvHandle:
         """Always available on a host that's already running Python
         (the decoder itself), so this never raises
@@ -438,6 +441,7 @@ def ensure_env(self, repo_root: Path) -> EnvHandle:
             "PythonBackend.ensure_env is not wired into the decoder.",
         )
 
+    @abstractmethod
     def test_command(
         self,
         env: EnvHandle,
@@ -450,6 +454,7 @@ def test_command(
             "build_batch_pytest_cmd for now.",
         )
 
+    @abstractmethod
     def install_deps_command(
         self,
         env: EnvHandle,
@@ -464,6 +469,7 @@ def install_deps_command(
     # 4. Test-output parsing — not wired into the decoder yet
     # ------------------------------------------------------------------
 
+    @abstractmethod
     def parse_test_output(self, raw: str, exit_code: int) -> TestRunResult:
         """Parse native Python test output when backend-driven tests run."""
         raise NotImplementedError(
diff --git a/CoderMind/utils/claude/llm_usage_count_coarse.py b/CoderMind/utils/claude/llm_usage_count_coarse.py
index 49fe89a..ec02829 100644
--- a/CoderMind/utils/claude/llm_usage_count_coarse.py
+++ b/CoderMind/utils/claude/llm_usage_count_coarse.py
@@ -22,11 +22,21 @@
 from typing import Dict, List, Optional
 
 # Import from the detailed counter
-from llm_usage_count import (
-    parse_file,
-    FileSummary,
-    _match_pricing,
-)
+if __package__:
+    from .llm_usage_count import (
+        parse_file,
+        FileSummary,
+        _match_pricing,
+    )
+else:
+    module_dir = str(Path(__file__).resolve().parent)
+    if module_dir not in sys.path:
+        sys.path.insert(0, module_dir)
+    from llm_usage_count import (
+        parse_file,
+        FileSummary,
+        _match_pricing,
+    )
 
 
 # ── Stage definitions ─────────────────────────────────────────────────────────

From da7bc2b413533b886e539afe686b67773bd0ca23 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 06:44:28 +0000
Subject: [PATCH 07/56] rpg_edit: merge to base branch instead of main branch.

---
 CoderMind/templates/commands/rpg_edit.md | 42 +++++++++++++++++-------
 1 file changed, 30 insertions(+), 12 deletions(-)

diff --git a/CoderMind/templates/commands/rpg_edit.md b/CoderMind/templates/commands/rpg_edit.md
index bb8550f..f467237 100644
--- a/CoderMind/templates/commands/rpg_edit.md
+++ b/CoderMind/templates/commands/rpg_edit.md
@@ -241,9 +241,16 @@ replies above before proceeding. Treat any other free-form reply as
 ### Step 5: Apply Changes (RPG-First, on a dedicated branch)
 
 All work in this step happens on a fresh `rpg-edit/<short-id>` branch
-in the project repo (workspace root), never directly on `main`.  The
-branch is merged into `main` only after Step 5e tests pass, so a
-failed run leaves `main` clean and the branch preserved for inspection.
+in the project repo (workspace root), never directly on the user's
+working branch.  The branch is merged back into `<base-branch>` — the
+branch the user was on when the command started — only after Step 5e
+tests pass, so a failed run leaves `<base-branch>` clean and the branch
+preserved for inspection.
+
+The user may be developing on any branch (a feature branch, not
+necessarily `main`).  Never assume `main`: capture the base branch in
+Step 5a and restore it on both the success and failure paths so the
+user's git environment is left exactly where they started.
 
 `<short-id>` should be derived from the plan filename or the first
 affected node id (e.g. last 8 chars of `feature_changes[0].node_id`).
@@ -259,9 +266,19 @@ test -z "$(git status --porcelain)" || {
   echo "Error: working tree has uncommitted changes. Commit or stash first."; exit 1;
 }
 
+# Capture the branch the user is currently on so we can merge back into
+# it (and restore it on failure).  Do NOT assume `main` — the user may
+# be developing on a feature branch.
+BASE_BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+echo "base branch: $BASE_BRANCH"
+
 git checkout -b rpg-edit/<short-id>
 ```
 
+Remember `<base-branch>` = the captured `$BASE_BRANCH` value — every
+later step that references `<base-branch>` means this branch, not
+`main`.
+
 If the precondition fails, surface the error to the user and stop —
 do **not** silently `git stash`, as that would hide their work.
 
@@ -339,22 +356,23 @@ If any test step fails: fix the code on the branch, re-run dep-refresh
 (Step 5c command), `git commit --amend --no-edit` to fold the
 fix into the same branch commit, then re-test.
 
-**Step 5e — Merge into `main` (only after Step 5d is green):**
+**Step 5e — Merge into `<base-branch>` (only after Step 5d is green):**
 
 ```bash
-git checkout main
+git checkout "$BASE_BRANCH"
 git merge --no-ff rpg-edit/<short-id> -m "rpg_edit: merge <short-id>"
 git branch -d rpg-edit/<short-id>
 ```
 
 `--no-ff` preserves the merge commit so the rpg_edit boundary is
-visible in `git log --graph`.
+visible in `git log --graph`.  The user is returned to `<base-branch>`
+— the same branch they started on.
 
 ### Step 6: Report Results
 
 - **Success path** (Step 5e completed):
 
-  > Merged `rpg-edit/<short-id>` into `main` (commit `<merge-SHA>`).
+  > Merged `rpg-edit/<short-id>` into `<base-branch>` (commit `<merge-SHA>`).
   > To revert later:
   > - Code:  `git revert -m 1 <merge-SHA>`
   > - Graphs: `cmind script rpg_edit/apply.py --rollback <timestamp> --json`
@@ -369,17 +387,17 @@ visible in `git log --graph`.
 
 - **Failure path** (Step 5d failed, Step 5e skipped):
 
-  Restore `main` and preserve the branch for the user to inspect:
+  Restore `<base-branch>` and preserve the branch for the user to inspect:
 
   ```bash
-  git checkout main
+  git checkout "$BASE_BRANCH"
   ```
 
   Report to the user:
 
   > Tests failed.  Branch `rpg-edit/<short-id>` preserved for inspection.
-  > `main` is clean.  Choose one of:
-  > - Inspect:  `git diff main rpg-edit/<short-id>`
+  > `<base-branch>` is clean.  Choose one of:
+  > - Inspect:  `git diff <base-branch> rpg-edit/<short-id>`
   > - Discard code + graphs together:
   >     `cmind script rpg_edit/apply.py --rollback <timestamp> --rollback-branch rpg-edit/<short-id> --json`
   > - Discard code only:  `git branch -D rpg-edit/<short-id>`
@@ -390,6 +408,6 @@ visible in `git log --graph`.
 1. **RPG is the anchor** — all modifications start from RPG feature graph nodes, not from files.
 2. **Three-way sync** — code, RPG, and dep_graph must stay consistent after every edit.
 3. **User confirmation** — always confirm the plan before applying changes. Never auto-apply.
-4. **Branch isolation** — `main` is touched only after tests pass. Failed runs leave the work on a `rpg-edit/<id>` branch for inspection.
+4. **Branch isolation** — `<base-branch>` (the branch the user started on) is touched only after tests pass, and the user is always returned to it. Never assume `main`. Failed runs leave the work on a `rpg-edit/<id>` branch for inspection.
 5. **Coordinated rollback** — `--rollback <ts> --rollback-branch <name>` reverts RPG, dep_graph, and the dedicated branch in one step.
 6. **Independent command** — does not depend on or invoke any other `/cmind.*` command.

From 2acefc3e5233e478d7458c8a5b8e9ffee3a413f2 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 06:44:53 +0000
Subject: [PATCH 08/56] fix: GitRunner init parameter main_branch.

---
 CoderMind/scripts/common/git_utils.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CoderMind/scripts/common/git_utils.py b/CoderMind/scripts/common/git_utils.py
index ebe40e3..c86abd1 100644
--- a/CoderMind/scripts/common/git_utils.py
+++ b/CoderMind/scripts/common/git_utils.py
@@ -85,12 +85,12 @@ class GitRunner:
     def __init__(
         self,
         repo_path: str,
-        main_branch: str = "main",
+        main_branch: str = MAIN_BRANCH,
         logger: Optional[logging.Logger] = None
     ):
         self.repo_path = Path(repo_path)
         self.logger = logger or logging.getLogger(__name__)
-        self.main_branch = self.MAIN_BRANCH
+        self.main_branch = main_branch
 
         # Ensure repo exists and is a git repo
         self._ensure_git_repository()
@@ -149,7 +149,7 @@ def _ensure_git_repository(self) -> None:
         if not git_dir.exists():
             self.logger.info("Initializing git repository...")
             self.repo_path.mkdir(parents=True, exist_ok=True)
-            self.run_git(["init", "-b", self.MAIN_BRANCH])
+            self.run_git(["init", "-b", self.main_branch])
 
         # Configure safe directory
         self.run_git([

From 294727f0866d360833177fb6535e4fd70fdcf9cd Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 08:53:05 +0000
Subject: [PATCH 09/56] fix: handle list-valued RPG meta paths in graph search

Normalize list-valued feature paths before searching so search_rpg with feature/all scope no longer crashes when RPG nodes map to multiple paths. Add regression coverage for list-valued meta.path entries.
---
 CoderMind/scripts/rpg/graph_query.py    | 28 ++++++++++++++++---------
 CoderMind/tests/test_encode_commands.py | 16 +++++++++++++-
 2 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/CoderMind/scripts/rpg/graph_query.py b/CoderMind/scripts/rpg/graph_query.py
index 734d07f..cc119a6 100644
--- a/CoderMind/scripts/rpg/graph_query.py
+++ b/CoderMind/scripts/rpg/graph_query.py
@@ -135,18 +135,26 @@ def from_files(cls, rpg_path: str, dep_graph_path: str = "") -> "GraphQueryEngin
     # Helpers
     # ------------------------------------------------------------------
 
-    def _normalize_path(self, meta_path: str) -> str:
-        """Strip redundant code_dir prefix from RPG meta.path.
-
-        For legacy data where ``_dep_graph_code_dir`` was ``"repo"``,
-        this converts e.g. ``repo/routes/auth.py`` to ``routes/auth.py``
-        so it aligns with dep_graph node IDs.  In the unified
-        workspace==repo layout the prefix is empty and this is a no-op.
-        """
+    def _normalize_path(self, meta_path: Any) -> Any:
+        """Strip redundant code_dir prefix from RPG meta.path."""
+        if isinstance(meta_path, list):
+            return [self._normalize_path(path) for path in meta_path]
+        if not isinstance(meta_path, str):
+            return meta_path
         if self._code_dir_prefix and meta_path.startswith(self._code_dir_prefix):
             return meta_path[len(self._code_dir_prefix):]
         return meta_path
 
+    def _path_search_text(self, meta_path: Any) -> str:
+        normalized_path = self._normalize_path(meta_path)
+        if isinstance(normalized_path, list):
+            return " ".join(
+                self._path_search_text(path) for path in normalized_path
+            )
+        if isinstance(normalized_path, str):
+            return normalized_path.split(":", 1)[0].lower()
+        return str(normalized_path).lower() if normalized_path else ""
+
     def _get_feature_path(self, node_id: str) -> str:
         """Build ancestor chain for an RPG node (excluding repo root)."""
         parts: list[str] = []
@@ -306,8 +314,8 @@ def _search_rpg_tree(self, query: str, top_k: int) -> List[Dict[str, Any]]:
             elif query in name.lower():
                 score = 75
             else:
-                file_part = meta_path.split(":")[0] if ":" in meta_path else meta_path
-                if query in file_part.lower():
+                path_text = self._path_search_text(meta_path)
+                if path_text and query in path_text:
                     score = 60
                 elif query in nid.lower():
                     score = 55
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 4014e39..e8aa194 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -533,7 +533,10 @@ def _make_rpg_with_dep_graph(tmp_path):
                     "name": "Core Logic",
                     "node_type": "functional_area",
                     "level": 1,
-                    "meta": {"type_name": "directory", "path": "."},
+                    "meta": {
+                        "type_name": "directory",
+                        "path": ["src/core.py", "src/extra.py"],
+                    },
                     "children": [
                         {
                             "id": "feat_1",
@@ -605,6 +608,17 @@ def test_graph_query_engine_search_feature(self, tmp_rpg_with_dep_graph):
         assert len(results) >= 1
         assert any(r["id"] == "area_1" for r in results)
 
+    def test_graph_query_engine_search_list_path(self, tmp_rpg_with_dep_graph):
+        from rpg.graph_query import GraphQueryEngine
+        engine = GraphQueryEngine.from_rpg_file(tmp_rpg_with_dep_graph)
+        feature_results = engine.search("src/core.py", scope="feature")
+        all_results = engine.search("src/extra.py", scope="all")
+        assert any(
+            r["id"] == "area_1" and r["path"] == ["src/core.py", "src/extra.py"]
+            for r in feature_results
+        )
+        assert any(r["id"] == "area_1" for r in all_results)
+
     def test_graph_query_engine_explore(self, tmp_rpg_with_dep_graph):
         """explore() should traverse edges from a node."""
         from rpg.graph_query import GraphQueryEngine

From 5e6930bb00512f2fb62006930ba3294894933a2e Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 09:04:21 +0000
Subject: [PATCH 10/56] rpg_edit: Add the structured event contract currently
 missing from the

---
 CoderMind/scripts/check_code_gen.py         |  24 +-
 CoderMind/scripts/common/run_events.py      | 234 +++++++++++++++++++
 CoderMind/scripts/common/run_report.py      | 241 +++++++-------------
 CoderMind/scripts/plan.py                   |  39 ++--
 CoderMind/scripts/rpg_edit/review.py        |  52 ++++-
 CoderMind/scripts/rpg_encoder/run_encode.py |  31 +--
 CoderMind/scripts/run_batch.py              |  33 +--
 CoderMind/scripts/update_graphs.py          |  67 +++---
 CoderMind/tests/test_encode_commands.py     |  14 +-
 CoderMind/tests/test_rpg_edit_run_report.py |  14 +-
 CoderMind/tests/test_run_report.py          | 127 ++++++++---
 11 files changed, 574 insertions(+), 302 deletions(-)
 create mode 100644 CoderMind/scripts/common/run_events.py

diff --git a/CoderMind/scripts/check_code_gen.py b/CoderMind/scripts/check_code_gen.py
index 387f439..5a0da18 100644
--- a/CoderMind/scripts/check_code_gen.py
+++ b/CoderMind/scripts/check_code_gen.py
@@ -29,6 +29,7 @@
     cmd_for,
     REPO_DIR,
 )
+from common.run_events import ArtifactEvent, CommandRun, StepEvent, VerificationEvent
 from common.run_report import write_command_report
 from common.execution_state import load_code_gen_state
 from common.execution_state import load_code_gen_state as _load_state, save_code_gen_state as _save_state
@@ -436,11 +437,11 @@ def determine_state(
 def _write_code_gen_report(result: Dict[str, Any]) -> str | None:
     try:
         stats = result.get("stats") or {}
-        report_path = write_command_report(
-            "code_gen",
+        report_path = write_command_report(CommandRun(
+            command="code_gen",
             title="CoderMind code_gen Progress View",
             status=result.get("type"),
-            summary_cards=[
+            summary=[
                 {"label": "state", "value": result.get("type", "")},
                 {"label": "total", "value": stats.get("total_tasks", 0)},
                 {"label": "completed", "value": stats.get("completed", 0)},
@@ -449,13 +450,16 @@ def _write_code_gen_report(result: Dict[str, Any]) -> str | None:
                 {"label": "current batch", "value": (result.get("current_batch") or {}).get("batch_id", "")},
                 {"label": "next batch", "value": result.get("next_batch", "")},
             ],
-            stages=[
-                {"name": "determine_state", "status": result.get("type"), "reason": result.get("message", "")},
-                {"name": "current_batch", "status": (result.get("current_batch") or {}).get("phase", "none"), "reason": (result.get("current_batch") or {}).get("file_path", "")},
-                {"name": "next_action", "status": "available" if result.get("next_action") else "missing", "reason": result.get("next_action", "")},
+            steps=[
+                StepEvent(name="determine_state", status=result.get("type"), reason=result.get("message", "")),
+                StepEvent(name="current_batch", status=(result.get("current_batch") or {}).get("phase", "none"), reason=(result.get("current_batch") or {}).get("file_path", "")),
+                StepEvent(name="next_action", status="available" if result.get("next_action") else "missing", reason=result.get("next_action", "")),
             ],
-            artifacts={"tasks": TASKS_FILE, "code_gen_state": STATE_FILE},
-            verification=[{"name": "state", "status": result.get("type"), "detail": result.get("message", "")}],
+            artifacts=[
+                ArtifactEvent(label="tasks", path=TASKS_FILE),
+                ArtifactEvent(label="code_gen_state", path=STATE_FILE),
+            ],
+            verification=[VerificationEvent(name="state", status=result.get("type"), detail=result.get("message", ""))],
             evidence={
                 "type": result.get("type"),
                 "stats": stats,
@@ -463,7 +467,7 @@ def _write_code_gen_report(result: Dict[str, Any]) -> str | None:
                 "next_batch": result.get("next_batch"),
                 "next_action": result.get("next_action"),
             },
-        )
+        ))
         return str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/scripts/common/run_events.py b/CoderMind/scripts/common/run_events.py
new file mode 100644
index 0000000..ca61bc0
--- /dev/null
+++ b/CoderMind/scripts/common/run_events.py
@@ -0,0 +1,234 @@
+"""Structured event contract for command run reports."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+
+def _to_plain(value: Any) -> Any:
+    if hasattr(value, "to_dict"):
+        return value.to_dict()
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, Mapping):
+        return {str(key): _to_plain(item_value) for key, item_value in value.items()}
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_to_plain(item) for item in value]
+    return value
+
+
+def _compact(values: Mapping[str, Any]) -> dict[str, Any]:
+    compacted: dict[str, Any] = {}
+    for key, value in values.items():
+        plain = _to_plain(value)
+        if plain is None or plain == "" or plain == [] or plain == {}:
+            continue
+        compacted[key] = plain
+    return compacted
+
+
+def _as_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        return [_to_plain(item) for item in value]
+    return [_to_plain(value)]
+
+
+def _artifact_status(path: Any, status: Any = None) -> Any:
+    if status not in (None, ""):
+        return status
+    if path in (None, ""):
+        return "missing"
+    try:
+        return "available" if Path(str(path)).expanduser().exists() else "missing"
+    except (OSError, ValueError):
+        return "missing"
+
+
+@dataclass
+class StepEvent:
+    name: Any = "step"
+    status: Any = "recorded"
+    reason: Any = None
+    duration: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "name": self.name,
+            "status": self.status,
+            "reason": self.reason,
+            "duration": self.duration,
+        })
+
+
+@dataclass
+class RetrievalEvent:
+    query: Any = None
+    tool: Any = None
+    hits: Any = None
+    reason: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "query": self.query,
+            "tool": self.tool,
+            "hits": self.hits,
+            "reason": self.reason,
+        })
+
+
+@dataclass
+class RPGDeltaEvent:
+    node_id: Any = None
+    name: Any = None
+    type: Any = None
+    path: Any = None
+    change: Any = None
+    score: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "node_id": self.node_id,
+            "name": self.name,
+            "type": self.type,
+            "path": self.path,
+            "change": self.change,
+            "score": self.score,
+        })
+
+
+@dataclass
+class DepGraphDeltaEvent:
+    dep_node_id: Any = None
+    path: Any = None
+    source_feature: Any = None
+    change: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "dep_node_id": self.dep_node_id,
+            "path": self.path,
+            "source_feature": self.source_feature,
+            "change": self.change,
+        })
+
+
+@dataclass
+class CodeDeltaEvent:
+    file: Any = None
+    change_type: Any = None
+    before: Any = None
+    after: Any = None
+    diff: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "file": self.file,
+            "change_type": self.change_type,
+            "before": self.before,
+            "after": self.after,
+            "diff": self.diff,
+        })
+
+
+@dataclass
+class VerificationEvent:
+    name: Any = "verification"
+    status: Any = None
+    detail: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "name": self.name,
+            "status": self.status,
+            "detail": self.detail,
+        })
+
+
+@dataclass
+class UserDecisionEvent:
+    decision: Any = None
+    branch: Any = None
+    before_state: Any = None
+    rollback_path: Any = None
+    confirmed: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "decision": self.decision,
+            "branch": self.branch,
+            "before_state": self.before_state,
+            "rollback_path": self.rollback_path,
+            "confirmed": self.confirmed,
+        })
+
+
+@dataclass
+class ArtifactEvent:
+    label: Any = "artifact"
+    path: Any = None
+    status: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return _compact({
+            "label": self.label,
+            "path": self.path,
+            "status": _artifact_status(self.path, self.status),
+        })
+
+
+@dataclass
+class CommandRun:
+    command: str = "command"
+    status: Any = None
+    title: Any = None
+    timestamp: Any = None
+    summary: Any = None
+    steps: Any = None
+    retrievals: Any = None
+    rpg_deltas: Any = None
+    dep_graph_deltas: Any = None
+    code_deltas: Any = None
+    verification: Any = None
+    user_decisions: Any = None
+    artifacts: Any = None
+    evidence: Any = None
+
+    def to_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "command": self.command,
+            "status": _to_plain(self.status),
+            "title": _to_plain(self.title),
+            "timestamp": _to_plain(self.timestamp),
+            "summary": _as_list(self.summary),
+            "steps": _as_list(self.steps),
+            "retrievals": _as_list(self.retrievals),
+            "rpg_deltas": _as_list(self.rpg_deltas),
+            "dep_graph_deltas": _as_list(self.dep_graph_deltas),
+            "code_deltas": _as_list(self.code_deltas),
+            "verification": _as_list(self.verification),
+            "user_decisions": _as_list(self.user_decisions),
+            "artifacts": _as_list(self.artifacts),
+            "evidence": _to_plain(self.evidence) if self.evidence is not None else {},
+        }
+        return _compact(data)
+
+
+__all__ = [
+    "CommandRun",
+    "StepEvent",
+    "RetrievalEvent",
+    "RPGDeltaEvent",
+    "DepGraphDeltaEvent",
+    "CodeDeltaEvent",
+    "VerificationEvent",
+    "UserDecisionEvent",
+    "ArtifactEvent",
+    "_compact",
+    "_to_plain",
+    "_as_list",
+    "_artifact_status",
+]
diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 9c03284..db73a71 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -11,67 +11,34 @@
 from urllib.parse import quote
 
 from common.paths import REPORTS_DIR
+from common.run_events import _to_plain
 
 _MAX_SUMMARY_CARDS = 7
 
 
 def write_command_report(
-    command: str | None = None,
-    payload: Any = None,
+    run: Any,
     *,
-    summary_cards: Any = None,
-    summary: Any = None,
-    stages: Any = None,
-    timeline: Any = None,
-    rpg_nodes: Any = None,
-    dep_nodes: Any = None,
-    artifacts: Any = None,
-    artifact_links: Any = None,
-    verification: Any = None,
-    evidence: Any = None,
-    evidence_json: Any = None,
-    status: str | None = None,
-    title: str | None = None,
     report_dir: str | Path | None = None,
     timestamp: str | datetime | None = None,
-    **extra: Any,
 ) -> Path:
     """Write a sanitized Explain View HTML report and return its path."""
-    if isinstance(payload, Mapping):
-        extra = {**dict(payload), **extra}
-    elif payload is not None:
-        extra.setdefault("payload", payload)
-    if command is None:
-        command = str(extra.pop("command", extra.pop("command_name", "command")))
-    summary_cards = summary_cards if summary_cards is not None else extra.pop("summary_cards", None)
-    summary = summary if summary is not None else extra.pop("summary", None)
-    stages = stages if stages is not None else extra.pop("stages", None)
-    timeline = timeline if timeline is not None else extra.pop("timeline", None)
-    rpg_nodes = rpg_nodes if rpg_nodes is not None else extra.pop("rpg_nodes", None)
-    dep_nodes = dep_nodes if dep_nodes is not None else extra.pop("dep_nodes", None)
-    artifacts = artifacts if artifacts is not None else extra.pop("artifacts", None)
-    artifact_links = artifact_links if artifact_links is not None else extra.pop("artifact_links", None)
-    verification = verification if verification is not None else extra.pop("verification", None)
-    evidence = evidence if evidence is not None else extra.pop("evidence", None)
-    evidence_json = evidence_json if evidence_json is not None else extra.pop("evidence_json", None)
-    status = status if status is not None else extra.pop("status", None)
-    title = title if title is not None else extra.pop("title", None)
-    report_dir = report_dir if report_dir is not None else extra.pop("report_dir", None)
-    timestamp = timestamp if timestamp is not None else extra.pop("timestamp", None)
-    summary_cards = summary_cards if summary_cards is not None else summary
-    stages = stages if stages is not None else timeline
-    artifacts = artifacts if artifacts is not None else artifact_links
-    evidence = evidence if evidence is not None else evidence_json
-
-    if rpg_nodes is None:
-        rpg_nodes = extra.pop("rpg_node_evidence", None) or extra.pop("rpg_evidence", None)
-    if dep_nodes is None:
-        dep_nodes = extra.pop("dep_node_evidence", None) or extra.pop("dep_evidence", None)
-    if isinstance(evidence, Mapping):
-        if rpg_nodes is None:
-            rpg_nodes = _evidence_nodes(evidence.get("rpg_nodes")) or _evidence_nodes(evidence.get("rpg_node_evidence"))
-        if dep_nodes is None:
-            dep_nodes = _evidence_nodes(evidence.get("dep_nodes")) or _evidence_nodes(evidence.get("dep_node_evidence"))
+    if hasattr(run, "to_dict"):
+        data = run.to_dict()
+    elif isinstance(run, Mapping):
+        data = dict(run)
+    else:
+        raise TypeError("write_command_report() expects a CommandRun or mapping")
+
+    data = _to_plain(data)
+    if not isinstance(data, Mapping):
+        raise TypeError("CommandRun.to_dict() must return a mapping")
+
+    command = str(data.get("command") or "command")
+    status = data.get("status")
+    title = data.get("title")
+    timestamp = timestamp if timestamp is not None else data.get("timestamp")
+    report_dir = report_dir if report_dir is not None else data.get("report_dir")
 
     generated_at = _display_timestamp(timestamp)
     filename_ts = _filename_timestamp(timestamp)
@@ -80,33 +47,19 @@ def write_command_report(
     target_dir.mkdir(parents=True, exist_ok=True)
     report_path = _unique_report_path(target_dir / f"cmind_run_{safe_command}_{filename_ts}.html")
 
-    aggregate_evidence = {
-        "command": command,
-        "status": status,
-        "summary_cards": summary_cards,
-        "stages": stages,
-        "rpg_nodes": rpg_nodes,
-        "dep_nodes": dep_nodes,
-        "artifacts": artifacts,
-        "verification": verification,
-        "evidence": evidence,
-    }
-    for key, value in extra.items():
-        aggregate_evidence[key] = value
-
     page_title = title or f"CoderMind {command} Explain View"
     html = _render_page(
         title=page_title,
         command=command,
         generated_at=generated_at,
         status=status,
-        summary_cards=_normalize_cards(summary_cards),
-        stages=_normalize_stages(stages),
-        rpg_nodes=_normalize_nodes(rpg_nodes),
-        dep_nodes=_normalize_nodes(dep_nodes),
-        artifacts=_normalize_artifacts(artifacts),
-        verification=_normalize_verification(verification),
-        evidence=aggregate_evidence,
+        summary_cards=_normalize_cards(data.get("summary")),
+        stages=_normalize_stages(data.get("steps")),
+        rpg_nodes=_normalize_nodes(data.get("rpg_deltas"), dep_graph=False),
+        dep_nodes=_normalize_nodes(data.get("dep_graph_deltas"), dep_graph=True),
+        artifacts=_normalize_artifacts(data.get("artifacts")),
+        verification=_normalize_verification(data.get("verification")),
+        evidence=dict(data),
     )
     report_path.write_text(html, encoding="utf-8")
     return report_path
@@ -153,7 +106,7 @@ def _as_sequence(value: Any) -> list[Any]:
     if isinstance(value, (str, bytes, Path)):
         return [value]
     if isinstance(value, Mapping):
-        return list(value.items())
+        return [value]
     if isinstance(value, Sequence):
         return list(value)
     return [value]
@@ -161,19 +114,13 @@ def _as_sequence(value: Any) -> list[Any]:
 
 def _normalize_cards(value: Any) -> list[dict[str, Any]]:
     cards: list[dict[str, Any]] = []
-    if isinstance(value, Mapping):
-        iterable = value.items()
-    else:
-        iterable = _as_sequence(value)
-    for item in iterable:
-        if isinstance(item, tuple) and len(item) == 2:
-            label, card_value = item
-            cards.append({"label": label, "value": card_value})
-        elif isinstance(item, Mapping):
-            label = item.get("label") or item.get("title") or item.get("name") or item.get("key") or "Summary"
-            card_value = item.get("value", item.get("count", item.get("text", "")))
-            detail = item.get("detail") or item.get("description")
-            cards.append({"label": label, "value": card_value, "detail": detail})
+    for item in _as_sequence(value):
+        if isinstance(item, Mapping):
+            cards.append({
+                "label": item.get("label") or "Summary",
+                "value": item.get("value", ""),
+                "detail": item.get("detail"),
+            })
         else:
             cards.append({"label": "Summary", "value": item})
     return cards[:_MAX_SUMMARY_CARDS]
@@ -182,68 +129,41 @@ def _normalize_cards(value: Any) -> list[dict[str, Any]]:
 def _normalize_stages(value: Any) -> list[dict[str, Any]]:
     stages: list[dict[str, Any]] = []
     for item in _as_sequence(value):
-        if isinstance(item, tuple) and len(item) == 2:
-            name, state = item
-            stages.append({"name": name, "status": state})
-        elif isinstance(item, Mapping):
-            name = item.get("name") or item.get("stage") or item.get("id") or "stage"
-            status = item.get("status") or item.get("state") or item.get("type") or item.get("action") or "recorded"
-            reason = item.get("reason") or item.get("message") or item.get("description") or ""
-            duration = item.get("duration") or item.get("elapsed") or item.get("elapsed_seconds")
-            stages.append({"name": name, "status": status, "reason": reason, "duration": duration})
+        if isinstance(item, Mapping):
+            stages.append({
+                "name": item.get("name") or "stage",
+                "status": item.get("status", "recorded"),
+                "reason": item.get("reason", ""),
+                "duration": item.get("duration"),
+            })
         else:
             stages.append({"name": item, "status": "recorded"})
     return stages
 
 
-def _evidence_nodes(value: Any) -> Any:
-    if isinstance(value, Mapping):
-        return value
-    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, Path)):
-        return value
-    return None
-
-
-def _normalize_nodes(value: Any) -> list[dict[str, Any]]:
+def _normalize_nodes(value: Any, *, dep_graph: bool = False) -> list[dict[str, Any]]:
     nodes: list[dict[str, Any]] = []
+    id_key = "dep_node_id" if dep_graph else "node_id"
     for item in _as_sequence(value):
-        if isinstance(item, tuple) and len(item) == 2:
-            node_id, node_value = item
-            if isinstance(node_value, Mapping):
-                entry = {"node_id": node_id, **dict(node_value)}
-            else:
-                entry = {"node_id": node_id, "value": node_value}
-        elif isinstance(item, Mapping):
+        if isinstance(item, Mapping):
             entry = dict(item)
         else:
-            entry = {"node_id": item}
+            entry = {id_key: item}
         nodes.append(entry)
     return nodes
 
 
 def _normalize_artifacts(value: Any) -> list[dict[str, Any]]:
     artifacts: list[dict[str, Any]] = []
-    if isinstance(value, Mapping):
-        iterable = value.items()
-    else:
-        iterable = _as_sequence(value)
-    for item in iterable:
-        if isinstance(item, tuple) and len(item) == 2:
-            label, path = item
-            artifacts.append({"label": label, "path": path, "status": _artifact_status(path)})
-        elif isinstance(item, Mapping):
-            path = item.get("path") or item.get("href") or item.get("url") or item.get("file")
-            label = item.get("label") or item.get("name") or item.get("title")
-            if path is None:
-                path_items = [
-                    (key, item_value)
-                    for key, item_value in item.items()
-                    if key not in {"label", "name", "title", "status"}
-                ]
-                if len(path_items) == 1:
-                    label, path = path_items[0]
-            label = label or path or "artifact"
-            artifacts.append({"label": label, "path": path, "status": _artifact_status(path, item.get("status"))})
+    for item in _as_sequence(value):
+        if isinstance(item, Mapping):
+            path = item.get("path")
+            artifacts.append({
+                "label": item.get("label") or path or "artifact",
+                "path": path,
+                "status": _artifact_status(path, item.get("status")),
+                "detail": item.get("detail"),
+            })
         else:
             artifacts.append({"label": Path(str(item)).name or "artifact", "path": item, "status": _artifact_status(item)})
     return artifacts
@@ -262,24 +182,13 @@ def _artifact_status(path: Any, status: Any = None) -> Any:
 
 def _normalize_verification(value: Any) -> list[dict[str, Any]]:
     checks: list[dict[str, Any]] = []
-    if isinstance(value, Mapping) and not any(isinstance(v, Mapping) for v in value.values()):
-        for key, check_value in value.items():
-            checks.append({"name": key, "status": check_value})
-        return checks
-    if isinstance(value, Mapping):
-        iterable = value.items()
-    else:
-        iterable = _as_sequence(value)
-    for item in iterable:
-        if isinstance(item, tuple) and len(item) == 2:
-            name, check_value = item
-            if isinstance(check_value, Mapping):
-                checks.append({"name": name, **dict(check_value)})
-            else:
-                checks.append({"name": name, "status": check_value})
-        elif isinstance(item, Mapping):
-            name = item.get("name") or item.get("check") or item.get("label") or "verification"
-            checks.append({"name": name, **dict(item)})
+    for item in _as_sequence(value):
+        if isinstance(item, Mapping):
+            checks.append({
+                "name": item.get("name") or "verification",
+                "status": item.get("status", ""),
+                "detail": item.get("detail"),
+            })
         else:
             checks.append({"name": "verification", "status": item})
     return checks
@@ -409,9 +318,9 @@ def _render_verification(checks: list[dict[str, Any]]) -> str:
         for check in checks:
             rows.append(
                 "<tr>"
-                f"<td>{_h(check.get('name') or check.get('check') or 'verification')}</td>"
-                f"<td>{_h(check.get('status', check.get('success', '')))}</td>"
-                f"<td>{_h(check.get('detail') or check.get('message') or check.get('reason') or '')}</td>"
+                f"<td>{_h(check.get('name') or 'verification')}</td>"
+                f"<td>{_h(check.get('status', ''))}</td>"
+                f"<td>{_h(check.get('detail', ''))}</td>"
                 "</tr>"
             )
         body = "<table><thead><tr><th>Check</th><th>Status</th><th>Detail</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
@@ -421,20 +330,28 @@ def _render_verification(checks: list[dict[str, Any]]) -> str:
 def _render_node_table(title: str, nodes: list[dict[str, Any]]) -> str:
     if not nodes:
         body = "<p class=\"empty\">No node evidence recorded.</p>"
+    elif any("dep_node_id" in node for node in nodes):
+        rows = []
+        for node in nodes:
+            rows.append(
+                "<tr>"
+                f"<td><code>{_h(node.get('dep_node_id', ''))}</code></td>"
+                f"<td>{_h(node.get('path', ''))}</td>"
+                f"<td>{_h(node.get('source_feature', ''))}</td>"
+                f"<td>{_h(node.get('change', ''))}</td>"
+                "</tr>"
+            )
+        body = "<table><thead><tr><th>ID</th><th>Path</th><th>Source feature</th><th>Change</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
     else:
         rows = []
         for node in nodes:
-            node_id = node.get("node_id") or node.get("id") or node.get("dep_node") or ""
-            node_type = node.get("type_name") or node.get("node_type") or node.get("type") or ""
-            path = node.get("meta_path") or node.get("path") or node.get("file_path") or node.get("feature_path") or ""
-            score = node.get("score") or node.get("weight") or node.get("status") or ""
             rows.append(
                 "<tr>"
-                f"<td><code>{_h(node_id)}</code></td>"
+                f"<td><code>{_h(node.get('node_id', ''))}</code></td>"
                 f"<td>{_h(node.get('name', ''))}</td>"
-                f"<td>{_h(node_type)}</td>"
-                f"<td>{_h(path)}</td>"
-                f"<td>{_h(score)}</td>"
+                f"<td>{_h(node.get('type', ''))}</td>"
+                f"<td>{_h(node.get('path', ''))}</td>"
+                f"<td>{_h(node.get('score', ''))}</td>"
                 "</tr>"
             )
         body = "<table><thead><tr><th>ID</th><th>Name</th><th>Type</th><th>Path</th><th>Score/status</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
diff --git a/CoderMind/scripts/plan.py b/CoderMind/scripts/plan.py
index 6a3a421..9ec9efc 100644
--- a/CoderMind/scripts/plan.py
+++ b/CoderMind/scripts/plan.py
@@ -70,6 +70,7 @@
     SKELETON_SUMMARY_FILE,
     TASKS_FILE,
 )
+from common.run_events import ArtifactEvent, CommandRun, StepEvent, VerificationEvent
 from common.run_report import write_command_report
 
 # ---------------------------------------------------------------------------
@@ -352,32 +353,40 @@ def _write_plan_report(
             cards.append({"label": "elapsed", "value": f"{elapsed:.1f}s"})
         if post_steps is not None:
             cards.append({"label": "post steps", "value": len(post_steps)})
-        timeline = _stage_rows(states)
+        stage_rows = _stage_rows(states)
+        artifact_rows = _plan_artifacts()
+        steps = [
+            StepEvent(name=row["name"], status=row["status"], reason=row.get("reason", ""))
+            for row in stage_rows
+        ]
         for post in post_steps or []:
-            timeline.append({
-                "name": post.get("name", "post-step"),
-                "status": "ok" if post.get("returncode") == 0 else "warning",
-                "reason": f"exit {post.get('returncode')}",
-            })
-        report_path = write_command_report(
-            "plan",
+            steps.append(StepEvent(
+                name=post.get("name", "post-step"),
+                status="ok" if post.get("returncode") == 0 else "warning",
+                reason=f"exit {post.get('returncode')}",
+            ))
+        report_path = write_command_report(CommandRun(
+            command="plan",
             title="CoderMind plan Explain View",
             status=mode,
-            summary_cards=cards,
-            stages=timeline,
-            artifacts=_plan_artifacts(),
+            summary=cards,
+            steps=steps,
+            artifacts=[
+                ArtifactEvent(label=row["label"], path=row["path"], status=row.get("status"))
+                for row in artifact_rows
+            ],
             verification=[
-                {"name": s.stage.name, "status": s.type, "detail": s.message or s.reason}
+                VerificationEvent(name=s.stage.name, status=s.type, detail=s.message or s.reason)
                 for s in states
             ],
             evidence={
                 "mode": mode,
                 "elapsed": elapsed,
-                "stages": _stage_rows(states),
+                "stages": stage_rows,
                 "post_steps": post_steps or [],
-                "artifacts": _plan_artifacts(),
+                "artifacts": artifact_rows,
             },
-        )
+        ))
         return str(report_path)
     except Exception:
         return None
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 9b4efc9..cadb764 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -44,6 +44,14 @@
     RPG_EDIT_CODE_RESULT_FILE,
     RPG_EDIT_REVIEW_RESULT_FILE,
 )
+from common.run_events import (  # noqa: E402
+    ArtifactEvent,
+    CommandRun,
+    DepGraphDeltaEvent,
+    RPGDeltaEvent,
+    StepEvent,
+    VerificationEvent,
+)
 from common.run_report import write_command_report  # noqa: E402
 
 logger = logging.getLogger(__name__)
@@ -197,18 +205,44 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
     artifacts = _load_review_artifacts(plan_path, impact_path)
     candidates = _selected_candidate_rows(artifacts)
     try:
-        report_path = write_command_report(
-            "rpg_edit",
+        report_path = write_command_report(CommandRun(
+            command="rpg_edit",
             title="CoderMind rpg_edit Explain View",
             status=str(result.get("type", "review")),
-            summary_cards=_review_summary_cards(result, artifacts),
-            stages=_review_timeline(result, artifacts),
-            rpg_nodes=candidates,
-            dep_nodes=_dep_node_rows(candidates),
-            artifacts=_artifact_links(plan_path, impact_path),
-            verification=_review_verification(result, artifacts),
+            summary=_review_summary_cards(result, artifacts),
+            steps=[
+                StepEvent(name=row.get("name", "stage"), status=row.get("status"), reason=row.get("reason", ""))
+                for row in _review_timeline(result, artifacts)
+            ],
+            rpg_deltas=[
+                RPGDeltaEvent(
+                    node_id=row.get("node_id"),
+                    name=row.get("name"),
+                    type=row.get("type"),
+                    path=row.get("path") or row.get("meta_path"),
+                    score=row.get("score"),
+                )
+                for row in candidates
+            ],
+            dep_graph_deltas=[
+                DepGraphDeltaEvent(
+                    dep_node_id=row.get("node_id"),
+                    path=row.get("path"),
+                    source_feature=row.get("source_feature"),
+                    change=row.get("change"),
+                )
+                for row in _dep_node_rows(candidates)
+            ],
+            artifacts=[
+                ArtifactEvent(label=row["label"], path=row["path"], status=row.get("status"))
+                for row in _artifact_links(plan_path, impact_path)
+            ],
+            verification=[
+                VerificationEvent(name=row.get("name", "verification"), status=row.get("status"), detail=row.get("detail"))
+                for row in _review_verification(result, artifacts)
+            ],
             evidence={"artifacts": artifacts, "review_result": result},
-        )
+        ))
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/scripts/rpg_encoder/run_encode.py b/CoderMind/scripts/rpg_encoder/run_encode.py
index f159dfb..6c299a1 100644
--- a/CoderMind/scripts/rpg_encoder/run_encode.py
+++ b/CoderMind/scripts/rpg_encoder/run_encode.py
@@ -27,6 +27,7 @@
 
 from common.paths import RPG_FILE, RPG_HTML_FILE, WORKSPACE_ROOT, ensure_cmind_dir  # noqa: E402
 from common.rpg_io import atomic_write_rpg  # noqa: E402
+from common.run_events import ArtifactEvent, CommandRun, StepEvent, VerificationEvent  # noqa: E402
 from common.run_report import write_command_report  # noqa: E402
 from common.trajectory import Trajectory  # noqa: E402
 
@@ -40,11 +41,11 @@ def _attach_encode_report(result: dict) -> dict:
             dep_summary.append(f"edges={result.get('dep_edges')}")
         if result.get("dep_to_rpg_map_size") is not None:
             dep_summary.append(f"mapped={result.get('dep_to_rpg_map_size')}")
-        report_path = write_command_report(
-            "encode",
+        report_path = write_command_report(CommandRun(
+            command="encode",
             title="CoderMind encode Explain View",
             status=result.get("status"),
-            summary_cards=[
+            summary=[
                 {"label": "repo", "value": result.get("repo_name", "unknown")},
                 {"label": "RPG nodes", "value": result.get("node_count", 0)},
                 {"label": "RPG edges", "value": result.get("edge_count", 0)},
@@ -53,20 +54,20 @@ def _attach_encode_report(result: dict) -> dict:
                 {"label": "visualization", "value": result.get("viz_path", result.get("viz_error", ""))},
                 {"label": "trajectory", "value": result.get("trajectory", "")},
             ],
-            stages=[
-                {"name": "parse_rpg", "status": "recorded", "reason": f"nodes={result.get('node_count', 0)}, edges={result.get('edge_count', 0)}"},
-                {"name": "dep_graph", "status": "recorded" if dep_summary else "not recorded", "reason": ", ".join(dep_summary)},
-                {"name": "save_rpg", "status": "recorded" if result.get("output_path") else "not recorded", "reason": result.get("output_path", "")},
-                {"name": "visualize", "status": "recorded" if result.get("viz_path") else "not recorded", "reason": result.get("viz_path") or result.get("viz_error", "")},
+            steps=[
+                StepEvent(name="parse_rpg", status="recorded", reason=f"nodes={result.get('node_count', 0)}, edges={result.get('edge_count', 0)}"),
+                StepEvent(name="dep_graph", status="recorded" if dep_summary else "not recorded", reason=", ".join(dep_summary)),
+                StepEvent(name="save_rpg", status="recorded" if result.get("output_path") else "not recorded", reason=result.get("output_path", "")),
+                StepEvent(name="visualize", status="recorded" if result.get("viz_path") else "not recorded", reason=result.get("viz_path") or result.get("viz_error", "")),
             ],
-            artifacts={
-                "rpg_json": result.get("output_path"),
-                "rpg_html": result.get("viz_path"),
-                "trajectory": result.get("trajectory"),
-            },
-            verification={"encode": result.get("status")},
+            artifacts=[
+                ArtifactEvent(label="rpg_json", path=result.get("output_path")),
+                ArtifactEvent(label="rpg_html", path=result.get("viz_path")),
+                ArtifactEvent(label="trajectory", path=result.get("trajectory")),
+            ],
+            verification=[VerificationEvent(name="encode", status=result.get("status"))],
             evidence=result,
-        )
+        ))
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/scripts/run_batch.py b/CoderMind/scripts/run_batch.py
index d31555c..02ce272 100644
--- a/CoderMind/scripts/run_batch.py
+++ b/CoderMind/scripts/run_batch.py
@@ -65,6 +65,7 @@
     cmd_for,
     REPO_DIR,
 )
+from common.run_events import ArtifactEvent, CommandRun, StepEvent, VerificationEvent
 from common.run_report import write_command_report
 from code_gen.context_collector import build_dependency_context
 from code_gen.prompts import (
@@ -929,11 +930,11 @@ def _write_batch_report(result: Dict[str, Any]) -> Optional[str]:
         return None
     try:
         stats = result.get("stats") or {}
-        report_path = write_command_report(
-            "code_gen",
+        report_path = write_command_report(CommandRun(
+            command="code_gen",
             title="CoderMind code_gen Batch View",
             status=result.get("type"),
-            summary_cards=[
+            summary=[
                 {"label": "result", "value": result.get("type", "")},
                 {"label": "success", "value": result.get("success", "")},
                 {"label": "batch", "value": result.get("batch_id", "")},
@@ -942,23 +943,23 @@ def _write_batch_report(result: Dict[str, Any]) -> Optional[str]:
                 {"label": "completed", "value": stats.get("completed", "")},
                 {"label": "failed", "value": stats.get("failed", result.get("failed", ""))},
             ],
-            stages=[
-                {"name": "batch", "status": result.get("type"), "reason": result.get("failure_reason") or result.get("message", "")},
-                {"name": "verification", "status": result.get("success"), "reason": f"passed={result.get('passed', '')} failed={result.get('failed', '')} errors={result.get('errors', '')}"},
-                {"name": "next_action", "status": "available" if result.get("next_action") else "missing", "reason": result.get("next_action", "")},
+            steps=[
+                StepEvent(name="batch", status=result.get("type"), reason=result.get("failure_reason") or result.get("message", "")),
+                StepEvent(name="verification", status=result.get("success"), reason=f"passed={result.get('passed', '')} failed={result.get('failed', '')} errors={result.get('errors', '')}"),
+                StepEvent(name="next_action", status="available" if result.get("next_action") else "missing", reason=result.get("next_action", "")),
+            ],
+            artifacts=[
+                ArtifactEvent(label="feature_spec", path=FEATURE_SPEC_FILE),
+                ArtifactEvent(label="tasks", path=TASKS_FILE),
+                ArtifactEvent(label="code_gen_state", path=STATE_FILE),
+                ArtifactEvent(label="rpg_json", path=REPO_RPG_FILE),
             ],
-            artifacts={
-                "feature_spec": FEATURE_SPEC_FILE,
-                "tasks": TASKS_FILE,
-                "code_gen_state": STATE_FILE,
-                "rpg_json": REPO_RPG_FILE,
-            },
             verification=[
-                {"name": "result", "status": result.get("success", result.get("type"))},
-                {"name": "pytest", "status": result.get("passed", ""), "detail": f"failed={result.get('failed', '')}, errors={result.get('errors', '')}"},
+                VerificationEvent(name="result", status=result.get("success", result.get("type"))),
+                VerificationEvent(name="pytest", status=result.get("passed", ""), detail=f"failed={result.get('failed', '')}, errors={result.get('errors', '')}"),
             ],
             evidence={"result": result},
-        )
+        ))
         return str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index 605e798..d4b2042 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -34,6 +34,7 @@
 
 from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE, RPG_HTML_FILE, HOOK_CALLS_LOG  # noqa: E402
 from common.rpg_io import atomic_write_rpg, safe_load_rpg  # noqa: E402
+from common.run_events import ArtifactEvent, CommandRun, StepEvent, VerificationEvent  # noqa: E402
 from common.run_report import write_command_report  # noqa: E402
 
 
@@ -167,11 +168,11 @@ def _attach_update_report(result: dict) -> dict:
         viz_status = result.get("viz_error") or (
             "ok" if result.get("viz_path") else "not recorded"
         )
-        report_path = write_command_report(
-            "update_rpg",
+        report_path = write_command_report(CommandRun(
+            command="update_rpg",
             title="CoderMind update_rpg Explain View",
             status=result.get("mode") or result.get("status"),
-            summary_cards=[
+            summary=[
                 {"label": "mode", "value": result.get("mode", "")},
                 {
                     "label": "reason",
@@ -192,48 +193,48 @@ def _attach_update_report(result: dict) -> dict:
                     "value": result.get("viz_path") or result.get("viz_error", ""),
                 },
             ],
-            stages=[
-                {
-                    "name": "git delta",
-                    "status": result.get("mode", ""),
-                    "reason": (
+            steps=[
+                StepEvent(
+                    name="git delta",
+                    status=result.get("mode", ""),
+                    reason=(
                         f"{git_total} changed files"
                         if git_total != ""
                         else "not recorded"
                     ),
-                },
-                {
-                    "name": "semantic delta",
-                    "status": result.get("mode", ""),
-                    "reason": _format_diff_summary(semantic_summary),
-                },
-                {
-                    "name": "sync graph",
-                    "status": result.get("status", result.get("mode", "")),
-                    "reason": result.get("reason", ""),
-                },
-                {
-                    "name": "visualize",
-                    "status": (
+                ),
+                StepEvent(
+                    name="semantic delta",
+                    status=result.get("mode", ""),
+                    reason=_format_diff_summary(semantic_summary),
+                ),
+                StepEvent(
+                    name="sync graph",
+                    status=result.get("status", result.get("mode", "")),
+                    reason=result.get("reason", ""),
+                ),
+                StepEvent(
+                    name="visualize",
+                    status=(
                         "ok"
                         if result.get("viz_path")
                         else "error"
                         if result.get("viz_error")
                         else "skipped"
                     ),
-                    "reason": result.get("viz_path") or result.get("viz_error", ""),
-                },
+                    reason=result.get("viz_path") or result.get("viz_error", ""),
+                ),
+            ],
+            artifacts=[
+                ArtifactEvent(label="rpg_json", path=rpg_path),
+                ArtifactEvent(label="rpg_html", path=result.get("viz_path")),
+            ],
+            verification=[
+                VerificationEvent(name="update_rpg", status=result.get("status", result.get("mode"))),
+                VerificationEvent(name="viz", status=viz_status),
             ],
-            artifacts={
-                "rpg_json": rpg_path,
-                "rpg_html": result.get("viz_path"),
-            },
-            verification={
-                "update_rpg": result.get("status", result.get("mode")),
-                "viz": viz_status,
-            },
             evidence=result,
-        )
+        ))
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index e8aa194..3af2f6d 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -402,9 +402,8 @@ def test_attach_update_report_uses_update_rpg_result_fields(tmp_path, monkeypatc
 
     captured = {}
 
-    def fake_write_command_report(command, **kwargs):
-        captured["command"] = command
-        captured.update(kwargs)
+    def fake_write_command_report(run):
+        captured.update(run.to_dict())
         return tmp_path / "report.html"
 
     monkeypatch.setattr(update_graphs, "write_command_report", fake_write_command_report)
@@ -432,15 +431,16 @@ def fake_write_command_report(command, **kwargs):
         "viz_path": "/tmp/rpg.html",
     })
 
-    cards = {card["label"]: card["value"] for card in captured["summary_cards"]}
+    cards = {card["label"]: card["value"] for card in captured["summary"]}
+    artifacts = {artifact["label"]: artifact["path"] for artifact in captured["artifacts"]}
     assert result["report_path"] == str(tmp_path / "report.html")
     assert cards["git files"] == 2
     assert cards["semantic files"] == 3
     assert cards["RPG nodes"] == "4504 (delta: +2)"
     assert cards["dep graph"] == "nodes=2708 (delta: +46), edges=5498 (delta: +103)"
-    assert captured["artifacts"]["rpg_json"] == "/tmp/rpg.json"
-    assert captured["stages"][0]["reason"] == "2 changed files"
-    assert captured["stages"][1]["reason"] == "3 semantic files, modified=3"
+    assert artifacts["rpg_json"] == "/tmp/rpg.json"
+    assert captured["steps"][0]["reason"] == "2 changed files"
+    assert captured["steps"][1]["reason"] == "3 semantic files, modified=3"
 
 
 # ============================================================================
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 257cd10..469f9f2 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -70,9 +70,10 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
 
-    def fake_write_command_report(*args, **kwargs):
+    def fake_write_command_report(run):
+        data = run.to_dict()
         review_artifact = next(
-            item for item in kwargs["artifacts"] if item["label"] == "review_result"
+            item for item in data["artifacts"] if item["label"] == "review_result"
         )
         assert review_artifact["status"] == "available"
         return report_path
@@ -112,10 +113,11 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
 
-    def fake_write_command_report(*args, **kwargs):
-        assert kwargs["rpg_nodes"] == [{"node_id": "planned", "name": "Planned Node", "dep_nodes": [dep_id]}]
-        assert kwargs["dep_nodes"] == [
-            {"node_id": dep_id, "source_feature": "planned", "path": "scripts/common/run_report.py"}
+    def fake_write_command_report(run):
+        data = run.to_dict()
+        assert data["rpg_deltas"] == [{"node_id": "planned", "name": "Planned Node"}]
+        assert data["dep_graph_deltas"] == [
+            {"dep_node_id": dep_id, "path": "scripts/common/run_report.py", "source_feature": "planned"}
         ]
         return report_path
 
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 6fef570..ecf90ad 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -8,26 +8,39 @@
 if str(_SCRIPTS) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS))
 
+from common.run_events import (
+    ArtifactEvent,
+    CodeDeltaEvent,
+    CommandRun,
+    DepGraphDeltaEvent,
+    RPGDeltaEvent,
+    RetrievalEvent,
+    StepEvent,
+    UserDecisionEvent,
+    VerificationEvent,
+)
 from common.run_report import write_command_report
 
 
 def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path) -> None:
     report = write_command_report(
-        "rpg/edit <script>alert(1)</script>",
-        title="Title <unsafe>",
-        status="ok <bad>",
-        summary_cards=[
-            {"label": "node", "value": "<script>alert(1)</script>"},
-            {"label": "count", "value": 3},
-        ],
-        stages=[{"name": "locate <x>", "status": "done", "reason": "score > 1"}],
-        rpg_nodes=[{"node_id": "feature<script>", "name": "Explain", "meta_path": "a.py"}],
-        dep_nodes=[{"node_id": "a.py:f", "path": "a.py"}],
-        artifacts={"plan": tmp_path / "plan.json"},
-        verification={"pytest": "passed"},
-        evidence={"raw": "<script>evil()</script>"},
+        CommandRun(
+            command="rpg/edit <script>alert(1)</script>",
+            title="Title <unsafe>",
+            status="ok <bad>",
+            summary=[
+                {"label": "node", "value": "<script>alert(1)</script>"},
+                {"label": "count", "value": 3},
+            ],
+            steps=[StepEvent(name="locate <x>", status="done", reason="score > 1")],
+            rpg_deltas=[RPGDeltaEvent(node_id="feature<script>", name="Explain", path="a.py")],
+            dep_graph_deltas=[DepGraphDeltaEvent(dep_node_id="a.py:f", path="a.py")],
+            artifacts=[ArtifactEvent(label="plan", path=tmp_path / "plan.json")],
+            verification=[VerificationEvent(name="pytest", status="passed")],
+            evidence={"raw": "<script>evil()</script>"},
+            timestamp="2026-06-30T12:34:56Z",
+        ),
         report_dir=tmp_path,
-        timestamp="2026-06-30T12:34:56Z",
     )
 
     assert report.parent == tmp_path
@@ -43,10 +56,12 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
 
 def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
     report = write_command_report(
-        "encode",
-        summary_cards=[{"label": f"card-{i}", "value": i} for i in range(9)],
+        CommandRun(
+            command="encode",
+            summary=[{"label": f"card-{i}", "value": i} for i in range(9)],
+            timestamp="fixed",
+        ),
         report_dir=tmp_path,
-        timestamp="fixed",
     )
 
     html = report.read_text(encoding="utf-8")
@@ -59,8 +74,8 @@ def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
 
 
 def test_write_command_report_preserves_same_timestamp_runs(tmp_path: Path) -> None:
-    first = write_command_report("update_rpg", report_dir=tmp_path, timestamp="fixed")
-    second = write_command_report("update_rpg", report_dir=tmp_path, timestamp="fixed")
+    first = write_command_report(CommandRun("update_rpg", timestamp="fixed"), report_dir=tmp_path)
+    second = write_command_report(CommandRun("update_rpg", timestamp="fixed"), report_dir=tmp_path)
 
     assert first != second
     assert first.name == "cmind_run_update_rpg_fixed.html"
@@ -71,10 +86,12 @@ def test_write_command_report_preserves_same_timestamp_runs(tmp_path: Path) -> N
 
 def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Path) -> None:
     report = write_command_report(
-        "encode",
-        evidence={"dep_nodes": 4, "rpg_nodes": 6},
+        CommandRun(
+            command="encode",
+            evidence={"dep_nodes": 4, "rpg_nodes": 6},
+            timestamp="fixed",
+        ),
         report_dir=tmp_path,
-        timestamp="fixed",
     )
 
     html = report.read_text(encoding="utf-8")
@@ -89,14 +106,19 @@ def test_write_command_report_infers_artifact_status_and_preserves_verification_
     missing = tmp_path / "missing.json"
 
     report = write_command_report(
-        "encode",
-        artifacts=[("rpg_json", available), {"missing_json": missing}],
-        verification=[
-            {"name": "message", "status": "ok", "message": "from message"},
-            {"name": "reason", "status": "warn", "reason": "from reason"},
-        ],
+        CommandRun(
+            command="encode",
+            artifacts=[
+                ArtifactEvent(label="rpg_json", path=available),
+                ArtifactEvent(label="missing_json", path=missing),
+            ],
+            verification=[
+                VerificationEvent(name="message", status="ok", detail="from message"),
+                VerificationEvent(name="reason", status="warn", detail="from reason"),
+            ],
+            timestamp="fixed",
+        ),
         report_dir=tmp_path,
-        timestamp="fixed",
     )
 
     html = report.read_text(encoding="utf-8")
@@ -106,3 +128,50 @@ def test_write_command_report_infers_artifact_status_and_preserves_verification_
     assert html.count("<td>missing</td>") == 1
     assert "<td>from message</td>" in html
     assert "<td>from reason</td>" in html
+
+
+def test_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:
+    available = tmp_path / "artifact.txt"
+    available.write_text("ok", encoding="utf-8")
+
+    events = [
+        StepEvent(),
+        RetrievalEvent(query="grep", tool="grep", hits=[{"path": "a.py"}], reason="matched"),
+        RPGDeltaEvent(node_id="feature", name="Feature", type="function", path="a.py", change="modified", score=1.0),
+        DepGraphDeltaEvent(dep_node_id="a.py:f", path="a.py", source_feature="feature", change="modified"),
+        CodeDeltaEvent(file="a.py", change_type="modify", before="old", after="new", diff="@@"),
+        VerificationEvent(),
+        UserDecisionEvent(decision="apply", branch="rpg-edit/x", before_state={"clean": True}, rollback_path="backup", confirmed=True),
+        ArtifactEvent(label="artifact", path=available),
+    ]
+
+    for event in events:
+        assert isinstance(event.to_dict(), dict)
+
+    run = CommandRun(
+        command="events",
+        retrievals=[events[1]],
+        rpg_deltas=[events[2]],
+        dep_graph_deltas=[events[3]],
+        code_deltas=[events[4]],
+        user_decisions=[events[6]],
+        artifacts=[events[7]],
+    ).to_dict()
+
+    assert run["retrievals"][0]["tool"] == "grep"
+    assert run["code_deltas"][0]["file"] == "a.py"
+    assert run["user_decisions"][0]["confirmed"] is True
+    assert run["artifacts"][0]["status"] == "available"
+
+
+def test_write_command_report_accepts_command_run_mapping(tmp_path: Path) -> None:
+    run = CommandRun(
+        command="mapping",
+        summary=[{"label": "safe", "value": "<ok>"}],
+        timestamp="fixed",
+    ).to_dict()
+
+    report = write_command_report(run, report_dir=tmp_path)
+
+    html = report.read_text(encoding="utf-8")
+    assert "&lt;ok&gt;" in html

From 46423f9c898dabf40bb52c590855f20213048963 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 10:13:01 +0000
Subject: [PATCH 11/56] rpg_edit: Extend _publish_review_report() at
 scripts/rpg_edit/review.p

---
 CoderMind/scripts/common/git_utils.py       | 163 +++++++++++++----
 CoderMind/scripts/common/run_report.py      | 142 ++++++++++++++-
 CoderMind/scripts/rpg_edit/review.py        | 182 ++++++++++++++++++-
 CoderMind/scripts/rpg_visualize.py          | 184 ++++++++++++++++++++
 CoderMind/tests/test_rpg_edit_run_report.py |  64 ++++++-
 CoderMind/tests/test_run_report.py          |  49 ++++++
 6 files changed, 743 insertions(+), 41 deletions(-)

diff --git a/CoderMind/scripts/common/git_utils.py b/CoderMind/scripts/common/git_utils.py
index c86abd1..b08e45c 100644
--- a/CoderMind/scripts/common/git_utils.py
+++ b/CoderMind/scripts/common/git_utils.py
@@ -391,11 +391,11 @@ def get_diff(
         to_commit: str = "HEAD"
     ) -> str:
         """Get diff between commits.
-        
+
         Args:
             from_commit: Start commit (default: parent of to_commit)
             to_commit: End commit (default: HEAD)
-            
+
         Returns:
             Diff content as string
         """
@@ -403,9 +403,24 @@ def get_diff(
             result = self.run_git(["diff", from_commit, to_commit])
         else:
             result = self.run_git(["diff", f"{to_commit}^", to_commit])
-        
+
         return result.stdout if result.success else ""
-    
+
+    def get_file_diffs(
+        self,
+        from_commit: Optional[str] = None,
+        to_commit: str = "HEAD",
+        files: Optional[List[str]] = None,
+    ) -> List[Dict[str, str]]:
+        """Get per-file diff rows between commits."""
+        return file_diffs_between(
+            self.repo_path,
+            from_commit,
+            to_commit,
+            files=files,
+            py_only=False,
+        )
+
     def get_changed_files(
         self,
         from_commit: Optional[str] = None,
@@ -617,6 +632,52 @@ def git_workspace_prefix(workspace_dir: str | Path) -> str:
 _GIT_STATUS_COPY_PREFIX = "C"
 
 
+def _parse_name_status_rows(
+    raw: Optional[str],
+    *,
+    py_only: bool = True,
+) -> List[Dict[str, str]]:
+    rows: List[Dict[str, str]] = []
+    if not raw:
+        return rows
+
+    def _keep(p: str) -> bool:
+        return (not py_only) or p.endswith(".py")
+
+    for line in raw.splitlines():
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        status = parts[0]
+        if status.startswith(_GIT_STATUS_RENAME_PREFIX) or status.startswith(
+            _GIT_STATUS_COPY_PREFIX
+        ):
+            if len(parts) < 3:
+                continue
+            old_path, new_path = parts[1], parts[2]
+            if _keep(new_path) or _keep(old_path):
+                rows.append({
+                    "file": new_path,
+                    "change_type": "rename" if status.startswith(_GIT_STATUS_RENAME_PREFIX) else "copy",
+                    "old_file": old_path,
+                    "status": status,
+                })
+            continue
+        path = parts[1]
+        if not _keep(path):
+            continue
+        if status == _GIT_STATUS_ADDED:
+            change_type = "add"
+        elif status == _GIT_STATUS_DELETED:
+            change_type = "delete"
+        elif status == _GIT_STATUS_MODIFIED:
+            change_type = "modify"
+        else:
+            continue
+        rows.append({"file": path, "change_type": change_type, "status": status})
+    return rows
+
+
 def _parse_name_status(
     raw: Optional[str],
     *,
@@ -644,40 +705,76 @@ def _parse_name_status(
     if not raw:
         return modified, renames
 
-    def _keep(p: str) -> bool:
-        return (not py_only) or p.endswith(".py")
-
-    for line in raw.splitlines():
-        parts = line.split("\t")
-        if len(parts) < 2:
-            continue
-        status = parts[0]
-        if status.startswith(_GIT_STATUS_RENAME_PREFIX) or status.startswith(
-            _GIT_STATUS_COPY_PREFIX
-        ):
-            if len(parts) < 3:
+    for row in _parse_name_status_rows(raw, py_only=py_only):
+        path = row.get("file", "")
+        if row.get("change_type") in ("rename", "copy"):
+            old_path = row.get("old_file", "")
+            if old_path and path:
+                renames[old_path] = path
+            if py_only and not path.endswith(".py"):
                 continue
-            old_path, new_path = parts[1], parts[2]
-            if _keep(new_path) or _keep(old_path):
-                renames[old_path] = new_path
-                # update_files() treats the OLD path as a deletion (via
-                # ``renames``) and the NEW path as something it must
-                # reparse — so we surface the new path through the
-                # modified list as well.
-                if _keep(new_path):
-                    modified.append(new_path)
-            continue
-        path = parts[1]
-        if not _keep(path):
-            continue
-        if status in (_GIT_STATUS_ADDED, _GIT_STATUS_DELETED, _GIT_STATUS_MODIFIED):
+        if path:
             modified.append(path)
-        # Type / unmerged / other status letters → ignore (caller will
-        # fall back to full sync via the safety threshold if there are
-        # many of them).
     return modified, renames
 
 
+def _diff_range_args(
+    from_commit: Optional[str] = None,
+    to_commit: str = "HEAD",
+) -> List[str]:
+    if from_commit:
+        return [from_commit, to_commit]
+    return [f"{to_commit}^", to_commit]
+
+
+def file_diffs_between(
+    repo_dir: str | Path,
+    from_commit: Optional[str] = None,
+    to_commit: str = "HEAD",
+    *,
+    files: Optional[List[str]] = None,
+    py_only: bool = False,
+) -> List[Dict[str, str]]:
+    """Return per-file diff rows without mutating git state."""
+    if not repo_dir:
+        return []
+    repo_path = Path(repo_dir)
+    if not repo_path.is_dir():
+        return []
+
+    range_args = _diff_range_args(from_commit, to_commit)
+    raw_status = _run_git_readonly(
+        ["diff", "--relative", "--name-status", "-M", *range_args],
+        repo_path,
+    )
+    rows = _parse_name_status_rows(raw_status, py_only=py_only)
+    if not rows:
+        return []
+
+    selected = {str(path) for path in files or [] if path}
+    diff_rows: List[Dict[str, str]] = []
+    for row in rows:
+        file_path = row.get("file", "")
+        old_file = row.get("old_file", "")
+        if selected and file_path not in selected and old_file not in selected:
+            continue
+        pathspecs = [path for path in [old_file, file_path] if path]
+        raw_diff = _run_git_readonly(
+            ["diff", *range_args, "--", *pathspecs],
+            repo_path,
+            timeout=10.0,
+        )
+        diff_row = {
+            "file": file_path,
+            "change_type": row.get("change_type", "modify"),
+            "diff": raw_diff or "",
+        }
+        if old_file:
+            diff_row["old_file"] = old_file
+        diff_rows.append(diff_row)
+    return diff_rows
+
+
 def staged_changes(
     repo_dir: str | Path,
 ) -> Tuple[List[str], Dict[str, str]]:
diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index db73a71..9fa3ba7 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -47,6 +47,12 @@ def write_command_report(
     target_dir.mkdir(parents=True, exist_ok=True)
     report_path = _unique_report_path(target_dir / f"cmind_run_{safe_command}_{filename_ts}.html")
 
+    evidence = dict(data)
+    evidence_data = evidence.get("evidence") if isinstance(evidence.get("evidence"), Mapping) else {}
+    retrievals = data.get("retrievals") or evidence_data.get("retrievals")
+    code_deltas = data.get("code_deltas") or evidence_data.get("code_deltas")
+    focused_graph = data.get("focused_graph") or evidence_data.get("focused_graph")
+
     page_title = title or f"CoderMind {command} Explain View"
     html = _render_page(
         title=page_title,
@@ -55,11 +61,14 @@ def write_command_report(
         status=status,
         summary_cards=_normalize_cards(data.get("summary")),
         stages=_normalize_stages(data.get("steps")),
+        retrievals=_normalize_retrievals(retrievals),
         rpg_nodes=_normalize_nodes(data.get("rpg_deltas"), dep_graph=False),
         dep_nodes=_normalize_nodes(data.get("dep_graph_deltas"), dep_graph=True),
+        code_deltas=_normalize_code_deltas(code_deltas),
+        focused_graph=_normalize_focused_graph(focused_graph),
         artifacts=_normalize_artifacts(data.get("artifacts")),
         verification=_normalize_verification(data.get("verification")),
-        evidence=dict(data),
+        evidence=evidence,
     )
     report_path.write_text(html, encoding="utf-8")
     return report_path
@@ -141,6 +150,22 @@ def _normalize_stages(value: Any) -> list[dict[str, Any]]:
     return stages
 
 
+def _normalize_retrievals(value: Any) -> list[dict[str, Any]]:
+    retrievals: list[dict[str, Any]] = []
+    for item in _as_sequence(value):
+        if isinstance(item, Mapping):
+            hits = item.get("hits")
+            retrievals.append({
+                "query": item.get("query", ""),
+                "tool": item.get("tool", ""),
+                "reason": item.get("reason", ""),
+                "hits": _as_sequence(hits),
+            })
+        else:
+            retrievals.append({"query": item, "hits": []})
+    return retrievals
+
+
 def _normalize_nodes(value: Any, *, dep_graph: bool = False) -> list[dict[str, Any]]:
     nodes: list[dict[str, Any]] = []
     id_key = "dep_node_id" if dep_graph else "node_id"
@@ -153,6 +178,30 @@ def _normalize_nodes(value: Any, *, dep_graph: bool = False) -> list[dict[str, A
     return nodes
 
 
+def _normalize_code_deltas(value: Any) -> list[dict[str, Any]]:
+    deltas: list[dict[str, Any]] = []
+    for item in _as_sequence(value):
+        if isinstance(item, Mapping):
+            deltas.append({
+                "file": item.get("file") or item.get("path") or "",
+                "change_type": item.get("change_type") or item.get("status") or "",
+                "before": item.get("before"),
+                "after": item.get("after"),
+                "diff": item.get("diff", ""),
+            })
+        else:
+            deltas.append({"file": item, "change_type": "recorded", "diff": ""})
+    return deltas
+
+
+def _normalize_focused_graph(value: Any) -> dict[str, Any]:
+    if value in (None, "", [], {}):
+        return {}
+    if isinstance(value, Mapping):
+        return dict(value)
+    return {"detail": value}
+
+
 def _normalize_artifacts(value: Any) -> list[dict[str, Any]]:
     artifacts: list[dict[str, Any]] = []
     for item in _as_sequence(value):
@@ -202,8 +251,11 @@ def _render_page(
     status: str | None,
     summary_cards: list[dict[str, Any]],
     stages: list[dict[str, Any]],
+    retrievals: list[dict[str, Any]],
     rpg_nodes: list[dict[str, Any]],
     dep_nodes: list[dict[str, Any]],
+    code_deltas: list[dict[str, Any]],
+    focused_graph: dict[str, Any],
     artifacts: list[dict[str, Any]],
     verification: list[dict[str, Any]],
     evidence: Mapping[str, Any],
@@ -238,6 +290,9 @@ def _render_page(
 .stage-head {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; }}
 .badge {{ font-size:12px; border-radius:999px; background:#eef2f7; padding:2px 8px; color:#334155; }}
 .reason {{ color:var(--muted); margin-top:4px; }}
+.delta {{ border:1px solid var(--line); border-radius:12px; padding:12px; margin:10px 0; background:#fbfdff; }}
+.delta-head {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin-bottom:8px; }}
+.hit-list {{ margin:0; padding-left:18px; }}
 table {{ width:100%; border-collapse:collapse; font-size:14px; table-layout:fixed; }}
 th, td {{ border-top:1px solid var(--line); padding:8px 10px; text-align:left; vertical-align:top; overflow-wrap:anywhere; word-break:break-word; }}
 th {{ color:var(--muted); font-weight:600; background:#fbfdff; }}
@@ -258,8 +313,11 @@ def _render_page(
 {_render_summary_cards(summary_cards)}
 {_render_timeline(stages)}
 {_render_verification(verification)}
+{_render_retrievals(retrievals)}
 {_render_node_table("Focused RPG node evidence", rpg_nodes)}
 {_render_node_table("Focused dependency node evidence", dep_nodes)}
+{_render_code_deltas(code_deltas)}
+{_render_focused_graph(focused_graph)}
 {_render_artifacts(artifacts)}
 {_render_evidence(evidence)}
 </main>
@@ -327,6 +385,88 @@ def _render_verification(checks: list[dict[str, Any]]) -> str:
     return f"<section><h2>Verification status</h2>{body}</section>"
 
 
+def _render_retrievals(retrievals: list[dict[str, Any]]) -> str:
+    if not retrievals:
+        return ""
+    rows = []
+    for retrieval in retrievals:
+        hits = retrieval.get("hits") or []
+        hit_items = []
+        for hit in hits:
+            if isinstance(hit, Mapping):
+                label = hit.get("node_id") or hit.get("dep_node_id") or hit.get("path") or hit.get("file") or hit.get("name") or "hit"
+                reason = hit.get("reason") or hit.get("score") or hit.get("status") or ""
+                hit_items.append(f"<li><code>{_h(label)}</code> {_h(reason)}</li>")
+            else:
+                hit_items.append(f"<li>{_h(hit)}</li>")
+        hits_html = "<span class=\"empty\">No hits recorded.</span>"
+        if hit_items:
+            hits_html = '<ul class="hit-list">' + "".join(hit_items) + "</ul>"
+        rows.append(
+            "<tr>"
+            f"<td>{_h(retrieval.get('tool', ''))}</td>"
+            f"<td>{_h(retrieval.get('query', ''))}</td>"
+            f"<td>{_h(retrieval.get('reason', ''))}</td>"
+            f"<td>{hits_html}</td>"
+            "</tr>"
+        )
+    body = "<table><thead><tr><th>Tool</th><th>Query</th><th>Reason</th><th>Hits</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+    return f"<section><h2>Retrieval evidence</h2>{body}</section>"
+
+
+def _render_code_deltas(deltas: list[dict[str, Any]]) -> str:
+    if not deltas:
+        return ""
+    blocks = []
+    for delta in deltas:
+        diff = delta.get("diff", "")
+        diff_html = "<p class=\"empty\">No diff recorded.</p>"
+        if diff:
+            diff_html = f"<details><summary>View diff</summary><pre>{_h(diff)}</pre></details>"
+        before_after = ""
+        if delta.get("before") is not None or delta.get("after") is not None:
+            before_after = (
+                "<details><summary>Before/after</summary>"
+                f"<pre>{_h({'before': delta.get('before'), 'after': delta.get('after')})}</pre>"
+                "</details>"
+            )
+        blocks.append(
+            "<div class=\"delta\">"
+            "<div class=\"delta-head\">"
+            f"<code>{_h(delta.get('file', ''))}</code>"
+            f"<span class=\"badge\">{_h(delta.get('change_type', ''))}</span>"
+            "</div>"
+            f"{diff_html}{before_after}"
+            "</div>"
+        )
+    return f"<section><h2>Code deltas</h2>{''.join(blocks)}</section>"
+
+
+def _render_focused_graph(focused_graph: dict[str, Any]) -> str:
+    if not focused_graph:
+        return ""
+    path = focused_graph.get("path") or focused_graph.get("artifact_path") or focused_graph.get("html_path")
+    href = _artifact_href(path) if path else "#"
+    rows = [
+        ("Status", focused_graph.get("status", "recorded"), False),
+        ("Graph artifact", f"<a href=\"{_h_attr(href)}\">{_h(path or '')}</a>" if path else "", True),
+        ("Selected RPG nodes", ", ".join(str(v) for v in focused_graph.get("selected_rpg_nodes") or focused_graph.get("rpg_node_ids") or []), False),
+        ("Selected dependency nodes", ", ".join(str(v) for v in focused_graph.get("selected_dep_nodes") or focused_graph.get("dep_node_ids") or []), False),
+        ("Included RPG nodes", focused_graph.get("rpg_node_count") or focused_graph.get("rpg_nodes") or "", False),
+        ("Included dependency nodes", focused_graph.get("dep_node_count") or focused_graph.get("dep_nodes") or "", False),
+    ]
+    table_rows = []
+    for label, value, is_html in rows:
+        if value in (None, ""):
+            continue
+        rendered = str(value) if is_html else _h(value)
+        table_rows.append(f"<tr><th>{_h(label)}</th><td>{rendered}</td></tr>")
+    table = "<table><tbody>" + "".join(table_rows) + "</tbody></table>" if table_rows else "<p class=\"empty\">No focused graph metadata recorded.</p>"
+    metadata = json.dumps(focused_graph, indent=2, ensure_ascii=False, default=_json_default)
+    inspector = f"<details><summary>Inspector metadata</summary><pre>{_h(metadata)}</pre></details>"
+    return f"<section><h2>Focused graph evidence</h2>{table}{inspector}</section>"
+
+
 def _render_node_table(title: str, nodes: list[dict[str, Any]]) -> str:
     if not nodes:
         body = "<p class=\"empty\">No node evidence recorded.</p>"
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index cadb764..460d7e4 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -36,6 +36,8 @@
 
 from common.paths import (  # noqa: E402
     REPO_DIR,
+    REPORTS_DIR,
+    REPO_RPG_FILE,
     cmd_for,
     RPG_EDIT_PLAN_FILE,
     RPG_EDIT_IMPACT_FILE,
@@ -46,12 +48,15 @@
 )
 from common.run_events import (  # noqa: E402
     ArtifactEvent,
+    CodeDeltaEvent,
     CommandRun,
     DepGraphDeltaEvent,
     RPGDeltaEvent,
+    RetrievalEvent,
     StepEvent,
     VerificationEvent,
 )
+from common.git_utils import file_diffs_between  # noqa: E402
 from common.run_report import write_command_report  # noqa: E402
 
 logger = logging.getLogger(__name__)
@@ -132,6 +137,140 @@ def _selected_candidate_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
     return rows
 
 
+def _listify(value: Any) -> List[Any]:
+    if value in (None, ""):
+        return []
+    if isinstance(value, (list, tuple, set)):
+        return [item for item in value if item not in (None, "")]
+    return [value]
+
+
+def _retrieval_hit_reason(candidate: Dict[str, Any], impact: Dict[str, Any]) -> str:
+    parts: List[str] = []
+    if candidate.get("score") not in (None, ""):
+        parts.append(f"locate score={candidate.get('score')}")
+    if candidate.get("feature_path"):
+        parts.append(f"feature path={candidate.get('feature_path')}")
+    dep_count = len(_listify(candidate.get("dep_nodes")))
+    if dep_count:
+        parts.append(f"{dep_count} dep nodes")
+    if impact.get("error"):
+        parts.append(f"impact error={impact.get('error')}")
+    if impact.get("message"):
+        parts.append(str(impact.get("message")))
+    summary = impact.get("impact_summary") if isinstance(impact.get("impact_summary"), dict) else {}
+    callers = summary.get("total_callers", len(impact.get("callers") or []))
+    files = summary.get("affected_file_count", len(impact.get("affected_files") or []))
+    if callers or files:
+        parts.append(f"impact callers={callers}, affected_files={files}")
+    return "; ".join(parts) or "selected by review plan"
+
+
+def _retrieval_rows(artifacts: Dict[str, Any], candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
+    impact_results = _impact_results(artifacts)
+    if locate or candidates:
+        hits: List[Dict[str, Any]] = []
+        for candidate in candidates:
+            node_id = candidate.get("node_id")
+            impact = impact_results.get(node_id) if isinstance(impact_results.get(node_id), dict) else {}
+            hits.append({
+                "node_id": node_id,
+                "name": candidate.get("name"),
+                "path": candidate.get("path") or candidate.get("meta_path"),
+                "score": candidate.get("score"),
+                "reason": _retrieval_hit_reason(candidate, impact),
+            })
+        rows.append({
+            "query": locate.get("query", ""),
+            "tool": str(RPG_EDIT_LOCATE_FILE),
+            "reason": f"{len(hits)} selected from {len(locate.get('results') or [])} locate candidates",
+            "hits": hits,
+        })
+    if impact_results:
+        hits = []
+        for node_id, impact in impact_results.items():
+            impact = impact if isinstance(impact, dict) else {}
+            hits.append({
+                "node_id": node_id,
+                "name": impact.get("name"),
+                "reason": _retrieval_hit_reason({"node_id": node_id}, impact),
+            })
+        rows.append({
+            "query": ", ".join(str(node_id) for node_id in impact_results),
+            "tool": str(RPG_EDIT_IMPACT_FILE),
+            "reason": f"{len(impact_results)} impact result sets",
+            "hits": hits,
+        })
+    return rows
+
+
+def _code_delta_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
+    files = [str(path) for path in _listify(code_result.get("files_modified"))]
+    commit_sha = code_result.get("commit_sha")
+    rows: List[Dict[str, Any]] = []
+    if commit_sha:
+        try:
+            rows = file_diffs_between(
+                REPO_DIR,
+                to_commit=str(commit_sha),
+                files=files or None,
+                py_only=False,
+            )
+        except Exception as exc:
+            rows = [{"file": path, "change_type": "modify", "diff": "", "error": str(exc)} for path in files]
+    seen = {row.get("file") for row in rows}
+    for path in files:
+        if path not in seen:
+            rows.append({"file": path, "change_type": "modify", "diff": ""})
+    return rows
+
+
+def _focused_graph_output_path() -> Path:
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+    return REPORTS_DIR / f"rpg_edit_focused_graph_{time.time_ns()}.html"
+
+
+def _focused_graph_artifact(candidates: List[Dict[str, Any]], artifacts: Dict[str, Any]) -> Dict[str, Any]:
+    dep_rows = _dep_node_rows(candidates)
+    selected_rpg = sorted({str(row.get("node_id")) for row in candidates if row.get("node_id")})
+    selected_dep = sorted({str(row.get("node_id")) for row in dep_rows if row.get("node_id")})
+    if not selected_rpg and not selected_dep:
+        return {}
+
+    metadata: Dict[str, Any] = {
+        "status": "recorded",
+        "selected_rpg_nodes": selected_rpg,
+        "selected_dep_nodes": selected_dep,
+    }
+    rpg_data = _load_json_artifact(REPO_RPG_FILE)
+    if not isinstance(rpg_data, dict):
+        metadata.update({"status": "missing", "reason": f"RPG file not available: {REPO_RPG_FILE}"})
+        return metadata
+
+    try:
+        from rpg_visualize import build_focused_graph_data, generate_html
+
+        focused_data = build_focused_graph_data(
+            rpg_data,
+            rpg_node_ids=selected_rpg,
+            dep_node_ids=selected_dep,
+        )
+        focused_meta = focused_data.get("_focused_graph") if isinstance(focused_data.get("_focused_graph"), dict) else {}
+        metadata.update(focused_meta)
+        if not (focused_meta.get("matched_rpg_nodes") or focused_meta.get("matched_dep_nodes")):
+            metadata.update({"status": "unavailable", "reason": "selected nodes not found in current RPG"})
+            return metadata
+        graph_path = _focused_graph_output_path()
+        graph_path.write_text(generate_html(focused_data), encoding="utf-8")
+        metadata.update({"status": "available", "path": str(graph_path)})
+    except Exception as exc:
+        metadata.update({"status": "error", "reason": str(exc)})
+    return metadata
+
+
 def _dep_node_path(dep_id: Any) -> str:
     if dep_id in (None, ""):
         return ""
@@ -200,12 +339,32 @@ def _review_verification(result: Dict[str, Any], artifacts: Dict[str, Any]) -> L
     return checks
 
 
+class _ReportPayload:
+    def __init__(self, run: CommandRun, focused_graph: Dict[str, Any]):
+        self.run = run
+        self.focused_graph = focused_graph
+
+    def to_dict(self) -> Dict[str, Any]:
+        data = self.run.to_dict()
+        if self.focused_graph:
+            data["focused_graph"] = self.focused_graph
+        return data
+
+
 def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path: Optional[Path]) -> Dict[str, Any]:
     _write_review_result(result)
     artifacts = _load_review_artifacts(plan_path, impact_path)
     candidates = _selected_candidate_rows(artifacts)
+    code_deltas = _code_delta_rows(artifacts)
+    focused_graph = _focused_graph_artifact(candidates, artifacts)
+    artifact_rows = _artifact_links(plan_path, impact_path)
+    if focused_graph.get("path"):
+        artifact_rows.append({"label": "focused_graph", "path": focused_graph["path"], "status": focused_graph.get("status")})
+    evidence = {"artifacts": artifacts, "review_result": result}
+    if focused_graph:
+        evidence["focused_graph"] = focused_graph
     try:
-        report_path = write_command_report(CommandRun(
+        report_run = CommandRun(
             command="rpg_edit",
             title="CoderMind rpg_edit Explain View",
             status=str(result.get("type", "review")),
@@ -233,16 +392,31 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
                 )
                 for row in _dep_node_rows(candidates)
             ],
+            retrievals=[
+                RetrievalEvent(query=row.get("query"), tool=row.get("tool"), hits=row.get("hits"), reason=row.get("reason"))
+                for row in _retrieval_rows(artifacts, candidates)
+            ],
             artifacts=[
                 ArtifactEvent(label=row["label"], path=row["path"], status=row.get("status"))
-                for row in _artifact_links(plan_path, impact_path)
+                for row in artifact_rows
+            ],
+            code_deltas=[
+                CodeDeltaEvent(
+                    file=row.get("file"),
+                    change_type=row.get("change_type"),
+                    before=row.get("before"),
+                    after=row.get("after"),
+                    diff=row.get("diff"),
+                )
+                for row in code_deltas
             ],
             verification=[
                 VerificationEvent(name=row.get("name", "verification"), status=row.get("status"), detail=row.get("detail"))
                 for row in _review_verification(result, artifacts)
             ],
-            evidence={"artifacts": artifacts, "review_result": result},
-        ))
+            evidence=evidence,
+        )
+        report_path = write_command_report(_ReportPayload(report_run, focused_graph))
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/scripts/rpg_visualize.py b/CoderMind/scripts/rpg_visualize.py
index 9f1b8de..e318073 100644
--- a/CoderMind/scripts/rpg_visualize.py
+++ b/CoderMind/scripts/rpg_visualize.py
@@ -227,6 +227,190 @@ def to_tree(nid):
             "children": [to_tree(r) for r in sorted(roots)]}
 
 
+def _id_set(values) -> set:
+    if values is None:
+        return set()
+    if isinstance(values, (str, bytes)):
+        values = [values]
+    return {str(value) for value in values if value not in (None, "")}
+
+
+def _collect_tree_ids(node: dict) -> set:
+    ids = set()
+    node_id = node.get("id")
+    if node_id not in (None, ""):
+        ids.add(str(node_id))
+    for child in node.get("children", []) or []:
+        ids.update(_collect_tree_ids(child))
+    return ids
+
+
+def _filter_tree(node: dict, keep_ids: set, *, keep_root: bool = True) -> dict | None:
+    children = [
+        child
+        for child in (_filter_tree(child, keep_ids, keep_root=False) for child in node.get("children", []) or [])
+        if child is not None
+    ]
+    node_id = str(node.get("id", ""))
+    if keep_root or node_id in keep_ids or children:
+        filtered = dict(node)
+        filtered["children"] = children
+        return filtered
+    return None
+
+
+def _expand_rpg_focus(data: dict, rpg_ids: set, dep_ids: set, include_neighbors: bool) -> set:
+    focus = set(rpg_ids)
+    dep_to_rpg = data.get("_dep_to_rpg_map", {}) if isinstance(data.get("_dep_to_rpg_map"), dict) else {}
+    for dep_id, mapped_rpg_ids in dep_to_rpg.items():
+        mapped = _id_set(mapped_rpg_ids)
+        if dep_id in dep_ids:
+            focus.update(mapped)
+        if focus.intersection(mapped):
+            dep_ids.add(str(dep_id))
+
+    if include_neighbors:
+        for edge in get_semantic_edges(data):
+            src = str(edge.get("src", ""))
+            dst = str(edge.get("dst", ""))
+            if src in focus or dst in focus:
+                focus.update([src, dst])
+    return focus
+
+
+def _dep_parent_map(dep_graph: dict) -> Dict[str, str]:
+    parent: Dict[str, str] = {}
+    for edge in dep_graph.get("edges", []) or []:
+        if edge.get("attrs", {}).get("type", "") in ("contains", "CONTAINS"):
+            parent[str(edge.get("dst", ""))] = str(edge.get("src", ""))
+    return {child: par for child, par in parent.items() if child and par}
+
+
+def _expand_dep_focus(data: dict, rpg_ids: set, dep_ids: set, include_neighbors: bool) -> set:
+    dep_graph = data.get("dep_graph", {}) if isinstance(data.get("dep_graph"), dict) else {}
+    raw_nodes = dep_graph.get("nodes", {}) if isinstance(dep_graph.get("nodes"), dict) else {}
+    focus = set(dep_ids)
+    dep_to_rpg = data.get("_dep_to_rpg_map", {}) if isinstance(data.get("_dep_to_rpg_map"), dict) else {}
+    for dep_id, mapped_rpg_ids in dep_to_rpg.items():
+        if rpg_ids.intersection(_id_set(mapped_rpg_ids)):
+            focus.add(str(dep_id))
+    for dep_id, attrs in raw_nodes.items():
+        if not isinstance(attrs, dict):
+            continue
+        mapped = _id_set(attrs.get("rpg_nodes"))
+        if mapped.intersection(rpg_ids):
+            focus.add(str(dep_id))
+        if str(dep_id) in focus:
+            rpg_ids.update(mapped)
+
+    if include_neighbors:
+        for edge in dep_graph.get("edges", []) or []:
+            edge_type = edge.get("attrs", {}).get("type", "")
+            if edge_type in ("contains", "CONTAINS"):
+                continue
+            src = str(edge.get("src", ""))
+            dst = str(edge.get("dst", ""))
+            if src in focus or dst in focus:
+                focus.update([src, dst])
+
+    parent = _dep_parent_map(dep_graph)
+    for dep_id in list(focus):
+        cur = dep_id
+        while cur in parent:
+            cur = parent[cur]
+            focus.add(cur)
+    for dep_id in list(focus):
+        attrs = raw_nodes.get(dep_id)
+        if isinstance(attrs, dict):
+            rpg_ids.update(_id_set(attrs.get("rpg_nodes")))
+        rpg_ids.update(_id_set(dep_to_rpg.get(dep_id)))
+    return focus
+
+
+def build_focused_graph_data(
+    data: dict,
+    *,
+    rpg_node_ids: List[str] | None = None,
+    dep_node_ids: List[str] | None = None,
+    include_neighbors: bool = True,
+) -> dict:
+    selected_rpg = _id_set(rpg_node_ids)
+    selected_dep = _id_set(dep_node_ids)
+    if not selected_rpg and not selected_dep:
+        return dict(data)
+
+    rpg_focus = _expand_rpg_focus(data, set(selected_rpg), set(selected_dep), include_neighbors)
+    dep_focus = _expand_dep_focus(data, rpg_focus, set(selected_dep), include_neighbors)
+    rpg_focus = _expand_rpg_focus(data, rpg_focus, dep_focus, include_neighbors=False)
+
+    tree = normalize_to_tree(data)
+    filtered_tree = _filter_tree(tree, rpg_focus) or {"id": "__root__", "name": "Focused graph", "children": []}
+    tree_ids = _collect_tree_ids(filtered_tree)
+    matched_rpg = sorted(selected_rpg.intersection(tree_ids))
+
+    semantic_edges = [
+        edge for edge in get_semantic_edges(data)
+        if str(edge.get("src", "")) in tree_ids and str(edge.get("dst", "")) in tree_ids
+    ]
+
+    dep_graph = data.get("dep_graph", {}) if isinstance(data.get("dep_graph"), dict) else {}
+    raw_nodes = dep_graph.get("nodes", {}) if isinstance(dep_graph.get("nodes"), dict) else {}
+    raw_edges = dep_graph.get("edges", []) if isinstance(dep_graph.get("edges"), list) else []
+    filtered_dep_nodes = {dep_id: attrs for dep_id, attrs in raw_nodes.items() if str(dep_id) in dep_focus}
+    filtered_dep_edges = [
+        edge for edge in raw_edges
+        if str(edge.get("src", "")) in dep_focus and str(edge.get("dst", "")) in dep_focus
+    ]
+    dep_ids = {str(dep_id) for dep_id in filtered_dep_nodes}
+    matched_dep = sorted(selected_dep.intersection(dep_ids))
+
+    dep_to_rpg = data.get("_dep_to_rpg_map", {}) if isinstance(data.get("_dep_to_rpg_map"), dict) else {}
+    filtered_map = {}
+    for dep_id, mapped_rpg_ids in dep_to_rpg.items():
+        if str(dep_id) not in dep_ids:
+            continue
+        mapped = [str(rpg_id) for rpg_id in mapped_rpg_ids if str(rpg_id) in tree_ids]
+        if mapped:
+            filtered_map[str(dep_id)] = mapped
+
+    focused = dict(data)
+    if isinstance(data.get("nodes"), list):
+        focused["nodes"] = [
+            dict(node) for node in data["nodes"]
+            if isinstance(node, dict) and str(node.get("id", "")) in tree_ids
+        ]
+    focused["root"] = filtered_tree
+    focused["edges"] = semantic_edges
+    focused["dep_graph"] = {**dep_graph, "nodes": filtered_dep_nodes, "edges": filtered_dep_edges}
+    focused["_dep_to_rpg_map"] = filtered_map
+    focused["_focused_graph"] = {
+        "selected_rpg_nodes": sorted(selected_rpg),
+        "selected_dep_nodes": sorted(selected_dep),
+        "matched_rpg_nodes": matched_rpg,
+        "matched_dep_nodes": matched_dep,
+        "rpg_node_count": len(tree_ids),
+        "dep_node_count": len(dep_ids),
+        "semantic_edge_count": len(semantic_edges),
+        "dep_edge_count": len(filtered_dep_edges),
+    }
+    return focused
+
+
+def generate_focused_html(
+    data: dict,
+    *,
+    rpg_node_ids: List[str] | None = None,
+    dep_node_ids: List[str] | None = None,
+    include_neighbors: bool = True,
+) -> str:
+    return generate_html(build_focused_graph_data(
+        data,
+        rpg_node_ids=rpg_node_ids,
+        dep_node_ids=dep_node_ids,
+        include_neighbors=include_neighbors,
+    ))
+
+
 def generate_html(data: dict) -> str:
     tree = normalize_to_tree(data)
     semantic_edges = get_semantic_edges(data)
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 469f9f2..3ac5dde 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -58,17 +58,58 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
     code_path = tmp_path / "code.json"
     review_path = tmp_path / "review.json"
     report_path = tmp_path / "report.html"
+    rpg_path = tmp_path / "rpg.json"
 
     validate_path.write_text(json.dumps({"type": "ready"}), encoding="utf-8")
-    locate_path.write_text(json.dumps({"type": "candidates", "results": [{"node_id": "n1", "name": "Node", "score": 1.0, "dep_nodes": ["a.py:f"]}]}), encoding="utf-8")
+    locate_path.write_text(
+        json.dumps({"type": "candidates", "query": "a.py", "results": [{"node_id": "n1", "name": "Node", "score": 1.0, "dep_nodes": ["a.py:f"]}]}),
+        encoding="utf-8",
+    )
     plan_path.write_text(json.dumps({"affected_nodes": ["n1"], "code_changes": [{"file_path": "a.py"}]}), encoding="utf-8")
-    impact_path.write_text(json.dumps({"type": "impact", "results": {"n1": {}}}), encoding="utf-8")
-    code_path.write_text(json.dumps({"success": True, "files_modified": ["a.py"], "last_status": "complete"}), encoding="utf-8")
+    impact_path.write_text(
+        json.dumps({
+            "type": "impact",
+            "results": {
+                "n1": {
+                    "name": "Node",
+                    "dep_nodes": ["a.py:f"],
+                    "affected_files": ["a.py"],
+                    "impact_summary": {"total_callers": 1, "affected_file_count": 1},
+                }
+            },
+        }),
+        encoding="utf-8",
+    )
+    code_path.write_text(json.dumps({"success": True, "commit_sha": "abc123", "files_modified": ["a.py"], "last_status": "complete"}), encoding="utf-8")
+    rpg_path.write_text(
+        json.dumps({
+            "repo_name": "test",
+            "root": {"id": "n1", "name": "Node", "node_type": "feature", "meta": {"path": "a.py"}, "children": []},
+            "edges": [],
+            "dep_graph": {
+                "nodes": {"a.py:f": {"name": "f", "type": "function", "module": "a.py", "rpg_nodes": ["n1"]}},
+                "edges": [],
+            },
+            "_dep_to_rpg_map": {"a.py:f": ["n1"]},
+        }),
+        encoding="utf-8",
+    )
 
     monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", validate_path)
     monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
+    monkeypatch.setattr(review, "RPG_EDIT_IMPACT_FILE", impact_path)
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
+    monkeypatch.setattr(review, "REPO_RPG_FILE", rpg_path)
+    monkeypatch.setattr(review, "REPORTS_DIR", tmp_path)
+
+    def fake_file_diffs_between(repo_dir, from_commit=None, to_commit="HEAD", *, files=None, py_only=False):
+        assert to_commit == "abc123"
+        assert files == ["a.py"]
+        assert py_only is False
+        return [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
+
+    monkeypatch.setattr(review, "file_diffs_between", fake_file_diffs_between)
 
     def fake_write_command_report(run):
         data = run.to_dict()
@@ -76,6 +117,17 @@ def fake_write_command_report(run):
             item for item in data["artifacts"] if item["label"] == "review_result"
         )
         assert review_artifact["status"] == "available"
+        assert data["retrievals"][0]["tool"] == str(locate_path)
+        assert data["retrievals"][0]["query"] == "a.py"
+        assert "locate score=1.0" in data["retrievals"][0]["hits"][0]["reason"]
+        assert "impact callers=1, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
+        assert data["retrievals"][1]["tool"] == str(impact_path)
+        assert data["code_deltas"] == [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
+        assert data["focused_graph"]["status"] == "available"
+        assert data["focused_graph"]["selected_rpg_nodes"] == ["n1"]
+        assert data["focused_graph"]["selected_dep_nodes"] == ["a.py:f"]
+        assert Path(data["focused_graph"]["path"]).exists()
+        assert any(item["label"] == "focused_graph" for item in data["artifacts"])
         return report_path
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
@@ -110,8 +162,10 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
 
     monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", validate_path)
     monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
+    monkeypatch.setattr(review, "RPG_EDIT_IMPACT_FILE", impact_path)
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
+    monkeypatch.setattr(review, "_focused_graph_artifact", lambda candidates, artifacts: {})
 
     def fake_write_command_report(run):
         data = run.to_dict()
@@ -119,6 +173,10 @@ def fake_write_command_report(run):
         assert data["dep_graph_deltas"] == [
             {"dep_node_id": dep_id, "path": "scripts/common/run_report.py", "source_feature": "planned"}
         ]
+        assert data["retrievals"][0]["hits"][0]["node_id"] == "planned"
+        assert "1 dep nodes" in data["retrievals"][0]["hits"][0]["reason"]
+        assert "impact callers=0, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
+        assert data["retrievals"][1]["tool"] == str(impact_path)
         return report_path
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index ecf90ad..7ffe7d5 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -54,6 +54,55 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
     assert "<script>alert(1)</script>" not in html
 
 
+def test_write_command_report_renders_retrievals_code_deltas_and_focused_graph(tmp_path: Path) -> None:
+    graph = tmp_path / "focused.html"
+    graph.write_text("graph", encoding="utf-8")
+    long_diff = "diff --git a/a.py b/a.py\n" + "\n".join(
+        f"+line {i} <script>alert({i})</script>" for i in range(40)
+    )
+
+    report = write_command_report(
+        {
+            "command": "rpg_edit",
+            "retrievals": [
+                RetrievalEvent(
+                    query="a.py",
+                    tool="RPG_EDIT_LOCATE_FILE",
+                    hits=[{"node_id": "n1<script>", "reason": "score < 1"}],
+                    reason="selected <hit>",
+                ).to_dict()
+            ],
+            "code_deltas": [
+                CodeDeltaEvent(file="a.py", change_type="modify", diff=long_diff).to_dict()
+            ],
+            "focused_graph": {
+                "path": graph,
+                "status": "available",
+                "selected_rpg_nodes": ["n1"],
+                "selected_dep_nodes": ["a.py:f"],
+                "rpg_node_count": 2,
+                "dep_node_count": 1,
+            },
+            "timestamp": "fixed",
+        },
+        report_dir=tmp_path,
+    )
+
+    html = report.read_text(encoding="utf-8")
+    assert "Retrieval evidence" in html
+    assert "Code deltas" in html
+    assert "Focused graph evidence" in html
+    assert "RPG_EDIT_LOCATE_FILE" in html
+    assert "n1&lt;script&gt;" in html
+    assert "+line 0 &lt;script&gt;alert(0)&lt;/script&gt;" in html
+    assert "+line 0 <script>alert(0)</script>" not in html
+    assert "<details><summary>View diff</summary>" in html
+    assert "<details open" not in html
+    assert html.count("<h2>Focused graph evidence</h2>") == 1
+    assert "Graph artifact" in html
+    assert "Inspector metadata" in html
+
+
 def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
     report = write_command_report(
         CommandRun(

From 40a51ba5f24d1b454d20bceb31107968c559b46a Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 10:31:39 +0000
Subject: [PATCH 12/56] fix(dep_graph): missing property.

---
 CoderMind/scripts/rpg/dep_graph.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CoderMind/scripts/rpg/dep_graph.py b/CoderMind/scripts/rpg/dep_graph.py
index 093228f..5397895 100644
--- a/CoderMind/scripts/rpg/dep_graph.py
+++ b/CoderMind/scripts/rpg/dep_graph.py
@@ -214,6 +214,7 @@ def __init__(self, repo_dir: str):
     _DERIVED_FIELDS = frozenset({
         "imports_from", "calls", "called_by",
         "inherits", "inherited_by",
+        "rpg_nodes",
     })
 
     # ------------------------------------------------------------------

From ccf9e62562b9a3f9978554f2e5c1fa3210aa8771 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 10:49:17 +0000
Subject: [PATCH 13/56] fix(rpg_edit): clear recovered code errors

Clear stale sub-agent errors once a later iteration completes so successful rpg_edit reports do not surface recovered timeouts.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/rpg_edit/code.py          |  1 +
 CoderMind/tests/test_rpg_edit_run_report.py | 30 +++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/CoderMind/scripts/rpg_edit/code.py b/CoderMind/scripts/rpg_edit/code.py
index 4c7e2f2..6d0172e 100644
--- a/CoderMind/scripts/rpg_edit/code.py
+++ b/CoderMind/scripts/rpg_edit/code.py
@@ -593,6 +593,7 @@ def apply_code_changes(
                 fp = c.get("file_path")
                 if fp and fp not in done_files:
                     done_files.append(fp)
+            last_error = None
             iter_info["detail"] = None
             break
         elif status == "partial":
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 3ac5dde..037c9cc 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -3,6 +3,7 @@
 import importlib.util
 import json
 import sys
+import types
 from pathlib import Path
 
 _REPO = Path(__file__).resolve().parents[1]
@@ -48,6 +49,35 @@ def test_code_result_is_persisted(tmp_path: Path, monkeypatch) -> None:
     assert data == {"success": True, "commit_sha": "abc123"}
 
 
+def test_code_result_clears_recovered_subagent_error(tmp_path: Path, monkeypatch) -> None:
+    code = _load_script("rpg_edit_code_retry_test", _SCRIPTS / "rpg_edit" / "code.py")
+
+    plan_path = tmp_path / "plan.json"
+    plan_path.write_text(
+        json.dumps({"code_changes": [{"file_path": "a.py", "description": "update report"}]}),
+        encoding="utf-8",
+    )
+    calls = iter([
+        (None, "Sub-agent failed after 900.1s: timeout"),
+        ("CODE_STATUS: COMPLETE", None),
+    ])
+    fake_run_batch = types.ModuleType("run_batch")
+    fake_run_batch.dispatch_sub_agent = lambda *args, **kwargs: next(calls)
+    monkeypatch.setitem(sys.modules, "run_batch", fake_run_batch)
+    monkeypatch.setattr(code, "_format_rpg_target_nodes", lambda plan, rpg_path: "nodes")
+    monkeypatch.setattr(code, "_format_impact_context", lambda plan: "impact")
+    monkeypatch.setattr(code, "_commit_changes", lambda repo_path, summary, status: "abc123")
+
+    result = code.apply_code_changes(plan_path, tmp_path / "rpg.json", tmp_path, max_iterations=2, timeout=1)
+
+    assert result["success"] is True
+    assert result["last_status"] == "complete"
+    assert result["last_error"] is None
+    assert result["commit_sha"] == "abc123"
+    assert result["iterations"][0]["parsed_status"] == "llm_error"
+    assert result["iterations"][1]["parsed_status"] == "complete"
+
+
 def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch) -> None:
     review = _load_script("rpg_edit_review_test", _SCRIPTS / "rpg_edit" / "review.py")
 

From 915a04b2175c5feb93df0a073e7889a3e1e5b97a Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 1 Jul 2026 11:08:07 +0000
Subject: [PATCH 14/56] rpg_edit: Add RPG_EDIT_APPLY_RESULT_FILE beside
 RPG_EDIT_PLAN_FILE/RPG

---
 CoderMind/scripts/common/paths.py           |   1 +
 CoderMind/scripts/common/run_events.py      |   4 +
 CoderMind/scripts/common/run_report.py      |  56 +++++++++
 CoderMind/scripts/rpg_edit/apply.py         | 133 +++++++++++++++++++-
 CoderMind/scripts/rpg_edit/review.py        |  61 ++++++++-
 CoderMind/tests/test_rpg_edit_run_report.py |  78 ++++++++++++
 CoderMind/tests/test_run_report.py          |  37 +++++-
 7 files changed, 366 insertions(+), 4 deletions(-)

diff --git a/CoderMind/scripts/common/paths.py b/CoderMind/scripts/common/paths.py
index 093e651..15c62b0 100644
--- a/CoderMind/scripts/common/paths.py
+++ b/CoderMind/scripts/common/paths.py
@@ -304,6 +304,7 @@ def cmd_for(script_relpath: str) -> str:
 RPG_EDIT_VALIDATE_FILE = DATA_DIR / "rpg_edit_validate.json"
 RPG_EDIT_LOCATE_FILE = DATA_DIR / "rpg_edit_locate.json"
 RPG_EDIT_CODE_RESULT_FILE = DATA_DIR / "rpg_edit_code_result.json"
+RPG_EDIT_APPLY_RESULT_FILE = DATA_DIR / "rpg_edit_apply_result.json"
 RPG_EDIT_REVIEW_RESULT_FILE = DATA_DIR / "rpg_edit_review_result.json"
 
 
diff --git a/CoderMind/scripts/common/run_events.py b/CoderMind/scripts/common/run_events.py
index ca61bc0..99ccf11 100644
--- a/CoderMind/scripts/common/run_events.py
+++ b/CoderMind/scripts/common/run_events.py
@@ -155,6 +155,8 @@ class UserDecisionEvent:
     before_state: Any = None
     rollback_path: Any = None
     confirmed: Any = None
+    apply_status: Any = None
+    test_status: Any = None
 
     def to_dict(self) -> dict[str, Any]:
         return _compact({
@@ -163,6 +165,8 @@ def to_dict(self) -> dict[str, Any]:
             "before_state": self.before_state,
             "rollback_path": self.rollback_path,
             "confirmed": self.confirmed,
+            "apply_status": self.apply_status,
+            "test_status": self.test_status,
         })
 
 
diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 9fa3ba7..d0bae9d 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -52,6 +52,7 @@ def write_command_report(
     retrievals = data.get("retrievals") or evidence_data.get("retrievals")
     code_deltas = data.get("code_deltas") or evidence_data.get("code_deltas")
     focused_graph = data.get("focused_graph") or evidence_data.get("focused_graph")
+    user_decisions = data.get("user_decisions") or evidence_data.get("user_decisions")
 
     page_title = title or f"CoderMind {command} Explain View"
     html = _render_page(
@@ -68,6 +69,7 @@ def write_command_report(
         focused_graph=_normalize_focused_graph(focused_graph),
         artifacts=_normalize_artifacts(data.get("artifacts")),
         verification=_normalize_verification(data.get("verification")),
+        user_decisions=_normalize_user_decisions(user_decisions),
         evidence=evidence,
     )
     report_path.write_text(html, encoding="utf-8")
@@ -243,6 +245,25 @@ def _normalize_verification(value: Any) -> list[dict[str, Any]]:
     return checks
 
 
+def _normalize_user_decisions(value: Any) -> list[dict[str, Any]]:
+    decisions: list[dict[str, Any]] = []
+    for item in _as_sequence(value):
+        if isinstance(item, Mapping):
+            entry = dict(item)
+        else:
+            entry = {"decision": item}
+        decisions.append({
+            "decision": entry.get("decision", ""),
+            "before_state": entry.get("before_state"),
+            "confirmed": entry.get("confirmed"),
+            "branch": entry.get("branch", ""),
+            "apply_status": entry.get("apply_status", ""),
+            "test_status": entry.get("test_status", ""),
+            "rollback_path": entry.get("rollback_path", ""),
+        })
+    return decisions
+
+
 def _render_page(
     *,
     title: str,
@@ -258,6 +279,7 @@ def _render_page(
     focused_graph: dict[str, Any],
     artifacts: list[dict[str, Any]],
     verification: list[dict[str, Any]],
+    user_decisions: list[dict[str, Any]],
     evidence: Mapping[str, Any],
 ) -> str:
     status_html = f"<span class=\"status\">{_h(status)}</span>" if status else ""
@@ -312,6 +334,7 @@ def _render_page(
 </header>
 {_render_summary_cards(summary_cards)}
 {_render_timeline(stages)}
+{_render_safety_boundary(user_decisions)}
 {_render_verification(verification)}
 {_render_retrievals(retrievals)}
 {_render_node_table("Focused RPG node evidence", rpg_nodes)}
@@ -385,6 +408,39 @@ def _render_verification(checks: list[dict[str, Any]]) -> str:
     return f"<section><h2>Verification status</h2>{body}</section>"
 
 
+def _render_safety_boundary(decisions: list[dict[str, Any]]) -> str:
+    if not decisions:
+        return ""
+    rows = []
+    for decision in decisions:
+        confirmed = decision.get("confirmed")
+        if confirmed is True:
+            confirmation = "confirmed"
+        elif confirmed is False:
+            confirmation = "not confirmed"
+        else:
+            confirmation = ""
+        rows.append(
+            "<tr>"
+            f"<td>{_h(decision.get('decision', ''))}</td>"
+            f"<td>{_h(decision.get('before_state'))}</td>"
+            f"<td>{_h(confirmation)}</td>"
+            f"<td>{_h(decision.get('branch', ''))}</td>"
+            f"<td>{_h(decision.get('apply_status', ''))}</td>"
+            f"<td>{_h(decision.get('test_status', ''))}</td>"
+            f"<td>{_h(decision.get('rollback_path', ''))}</td>"
+            "</tr>"
+        )
+    body = (
+        "<table><thead><tr><th>Decision</th><th>Before state</th>"
+        "<th>Confirmation</th><th>Branch</th><th>Apply status</th>"
+        "<th>Test status</th><th>Rollback path</th></tr></thead><tbody>"
+        + "".join(rows)
+        + "</tbody></table>"
+    )
+    return f"<section><h2>Safety boundary</h2>{body}</section>"
+
+
 def _render_retrievals(retrievals: list[dict[str, Any]]) -> str:
     if not retrievals:
         return ""
diff --git a/CoderMind/scripts/rpg_edit/apply.py b/CoderMind/scripts/rpg_edit/apply.py
index 2421576..8f60827 100644
--- a/CoderMind/scripts/rpg_edit/apply.py
+++ b/CoderMind/scripts/rpg_edit/apply.py
@@ -8,6 +8,7 @@
 
 import argparse
 import json
+import shlex
 import shutil
 import subprocess
 import sys
@@ -21,7 +22,15 @@
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
-from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE, REPO_DIR, RPG_EDIT_PLAN_FILE  # noqa: E402
+from common.paths import (  # noqa: E402
+    REPO_RPG_FILE,
+    DEP_GRAPH_FILE,
+    REPO_DIR,
+    RPG_EDIT_PLAN_FILE,
+    RPG_EDIT_APPLY_RESULT_FILE,
+    cmd_for,
+)
+from common.git_utils import read_head  # noqa: E402
 
 
 def _backup(rpg_path: Path, dep_graph_path: Path, ts: str) -> Dict[str, str]:
@@ -50,6 +59,57 @@ def _rollback(backups: Dict[str, str], rpg_path: Path, dep_graph_path: Path) ->
         shutil.copy2(backups["dep_graph"], dep_graph_path)
 
 
+def _rollback_command(timestamp: str | None, before_state: dict | None) -> str | None:
+    if not timestamp:
+        return None
+    command = f"{cmd_for('rpg_edit/apply.py')} --rollback {shlex.quote(str(timestamp))}"
+    branch = before_state.get("head_branch") if isinstance(before_state, dict) else None
+    if branch:
+        command += f" --rollback-branch {shlex.quote(str(branch))}"
+    return command
+
+
+def _rollback_path(backups: Dict[str, str]) -> str | None:
+    return backups.get("rpg") or backups.get("dep_graph")
+
+
+def _persist_apply_result(result: Dict[str, Any]) -> None:
+    RPG_EDIT_APPLY_RESULT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    RPG_EDIT_APPLY_RESULT_FILE.write_text(
+        json.dumps(result, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
+def _record_apply_result(
+    result: Dict[str, Any],
+    *,
+    backup_timestamp: str | None = None,
+    backups: Dict[str, str] | None = None,
+    applied_features: list | None = None,
+    dep_graph_refreshed: bool | None = None,
+    before_state: dict | None = None,
+    confirmed: bool | None = None,
+) -> Dict[str, Any]:
+    backups = backups or {}
+    if backup_timestamp is not None:
+        result.setdefault("backup_timestamp", backup_timestamp)
+        result.setdefault("rollback_command", _rollback_command(backup_timestamp, before_state))
+    result.setdefault("backups", backups)
+    result.setdefault("applied_features", applied_features or [])
+    if dep_graph_refreshed is not None:
+        result.setdefault("dep_graph_refreshed", dep_graph_refreshed)
+    rollback_path = _rollback_path(backups)
+    if rollback_path:
+        result.setdefault("rollback_path", rollback_path)
+    if before_state is not None:
+        result.setdefault("before_state", before_state)
+    if confirmed is not None:
+        result.setdefault("confirmed", confirmed)
+    _persist_apply_result(result)
+    return result
+
+
 def apply_feature_changes(svc, changes: list) -> list:
     """Apply feature_changes to the RPG in memory.
 
@@ -128,6 +188,8 @@ def main():
     parser.add_argument("--backup-ts", type=str, default=None,
                         help="Reuse existing backup timestamp (skip new backup)")
     parser.add_argument("--skip-tests", action="store_true")
+    parser.add_argument("--confirmed", action="store_const", const=True, default=None,
+                        help="Record that the apply boundary was explicitly confirmed")
     parser.add_argument("--rollback", type=str, default=None,
                         help="Rollback to a previous timestamp backup")
     parser.add_argument("--rollback-branch", type=str, default=None,
@@ -145,6 +207,8 @@ def main():
     from common.logging_setup import setup_file_logging
     setup_file_logging("rpg_edit")
 
+    before_state = read_head(REPO_DIR)
+
     # Handle rollback
     if args.rollback:
         rpg_backup = args.rpg.with_suffix(f".before-edit-{args.rollback}.json")
@@ -180,10 +244,23 @@ def main():
                     "message": f"git invocation failed: {exc}",
                 }
 
+        rollback_backups = {}
+        if rpg_backup.exists():
+            rollback_backups["rpg"] = str(rpg_backup)
+        if dg_backup.exists():
+            rollback_backups["dep_graph"] = str(dg_backup)
         result = {"type": "rollback", "restored": restored,
                   "timestamp": args.rollback}
         if branch_result:
             result["branch"] = branch_result
+        _record_apply_result(
+            result,
+            backup_timestamp=args.rollback,
+            backups=rollback_backups,
+            dep_graph_refreshed=False,
+            before_state=before_state,
+            confirmed=args.confirmed,
+        )
         print(json.dumps(result, indent=2) if args.json else
               f"Rolled back: {restored}" +
               (f"; branch={branch_result}" if branch_result else ""))
@@ -192,6 +269,12 @@ def main():
     # Load plan
     if not args.plan.exists():
         result = {"type": "error", "message": f"Plan not found: {args.plan}"}
+        _record_apply_result(
+            result,
+            dep_graph_refreshed=False,
+            before_state=before_state,
+            confirmed=args.confirmed,
+        )
         print(json.dumps(result) if args.json else f"Error: {result['message']}")
         return 1
 
@@ -214,6 +297,7 @@ def main():
 
     # --- Phase: rpg-only or all → apply feature_changes ---
     applied_features = []
+    dep_graph_refreshed = False
     if args.phase in ("rpg-only", "all"):
         feature_changes = plan.get("feature_changes", [])
         applied_features = apply_feature_changes(svc, feature_changes) if feature_changes else []
@@ -226,12 +310,20 @@ def main():
                 "backup_timestamp": ts,
                 "backups": backups,
             }
+            _record_apply_result(
+                result,
+                backup_timestamp=ts,
+                backups=backups,
+                applied_features=applied_features,
+                dep_graph_refreshed=dep_graph_refreshed,
+                before_state=before_state,
+                confirmed=args.confirmed,
+            )
             print(json.dumps(result, indent=2) if args.json else
                   f"RPG updated ({len(applied_features)} features). Backup: {ts}")
             return 0
 
     # --- Phase: dep-refresh or all → refresh dep_graph ---
-    dep_graph_refreshed = False
     if args.phase in ("dep-refresh", "all"):
         # Workspace root is the project repo root.  Explicit ``--repo``
         # still wins for tests / brownfield setups where the code lives
@@ -252,6 +344,15 @@ def main():
                     "message": f"dep_graph refresh failed: {exc}",
                     "backup_timestamp": ts,
                 }
+                _record_apply_result(
+                    result,
+                    backup_timestamp=ts,
+                    backups=backups,
+                    applied_features=applied_features,
+                    dep_graph_refreshed=dep_graph_refreshed,
+                    before_state=before_state,
+                    confirmed=args.confirmed,
+                )
                 print(json.dumps(result, indent=2) if args.json else
                       f"Error: {result['message']}")
                 return 1
@@ -264,6 +365,15 @@ def main():
                 "dep_graph_refreshed": dep_graph_refreshed,
                 "backup_timestamp": ts,
             }
+            _record_apply_result(
+                result,
+                backup_timestamp=ts,
+                backups=backups,
+                applied_features=applied_features,
+                dep_graph_refreshed=dep_graph_refreshed,
+                before_state=before_state,
+                confirmed=args.confirmed,
+            )
             print(json.dumps(result, indent=2) if args.json else
                   f"dep_graph refreshed: {dep_graph_refreshed}. Backup: {ts}")
             return 0
@@ -293,9 +403,19 @@ def main():
                     "type": "test_failed",
                     "applied_features": applied_features,
                     "test_output": test_result["output"],
+                    "test_result": test_result,
                     "rolled_back": True,
                     "backup_timestamp": ts,
                 }
+                _record_apply_result(
+                    result,
+                    backup_timestamp=ts,
+                    backups=backups,
+                    applied_features=applied_features,
+                    dep_graph_refreshed=dep_graph_refreshed,
+                    before_state=before_state,
+                    confirmed=args.confirmed,
+                )
                 print(json.dumps(result, indent=2) if args.json else
                       f"Tests failed. Rolled back to {ts}.")
                 return 1
@@ -309,6 +429,15 @@ def main():
         "backup_timestamp": ts,
         "backups": backups,
     }
+    _record_apply_result(
+        result,
+        backup_timestamp=ts,
+        backups=backups,
+        applied_features=applied_features,
+        dep_graph_refreshed=dep_graph_refreshed,
+        before_state=before_state,
+        confirmed=args.confirmed,
+    )
     print(json.dumps(result, indent=2) if args.json else "EditPlan applied successfully.")
     return 0
 
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 460d7e4..ab8bc0e 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -44,6 +44,7 @@
     RPG_EDIT_VALIDATE_FILE,
     RPG_EDIT_LOCATE_FILE,
     RPG_EDIT_CODE_RESULT_FILE,
+    RPG_EDIT_APPLY_RESULT_FILE,
     RPG_EDIT_REVIEW_RESULT_FILE,
 )
 from common.run_events import (  # noqa: E402
@@ -54,9 +55,10 @@
     RPGDeltaEvent,
     RetrievalEvent,
     StepEvent,
+    UserDecisionEvent,
     VerificationEvent,
 )
-from common.git_utils import file_diffs_between  # noqa: E402
+from common.git_utils import file_diffs_between, read_head  # noqa: E402
 from common.run_report import write_command_report  # noqa: E402
 
 logger = logging.getLogger(__name__)
@@ -86,6 +88,7 @@ def _load_review_artifacts(plan_path: Path, impact_path: Optional[Path]) -> Dict
         "plan": _load_json_artifact(plan_path),
         "impact": _load_json_artifact(impact_path),
         "code_result": _load_json_artifact(RPG_EDIT_CODE_RESULT_FILE),
+        "apply_result": _load_json_artifact(RPG_EDIT_APPLY_RESULT_FILE),
     }
 
 
@@ -96,6 +99,7 @@ def _artifact_links(plan_path: Path, impact_path: Optional[Path]) -> List[Dict[s
         "plan": plan_path,
         "impact": impact_path,
         "code_result": RPG_EDIT_CODE_RESULT_FILE,
+        "apply_result": RPG_EDIT_APPLY_RESULT_FILE,
         "review_result": RPG_EDIT_REVIEW_RESULT_FILE,
     }
     links: List[Dict[str, Any]] = []
@@ -339,6 +343,60 @@ def _review_verification(result: Dict[str, Any], artifacts: Dict[str, Any]) -> L
     return checks
 
 
+def _status_from_bool(value: Any) -> Optional[str]:
+    if value is True:
+        return "passed"
+    if value is False:
+        return "failed"
+    return None
+
+
+def _apply_status(apply_result: Dict[str, Any]) -> Any:
+    return apply_result.get("type") or apply_result.get("status") or "missing"
+
+
+def _test_status(result: Dict[str, Any], code_result: Dict[str, Any], apply_result: Dict[str, Any]) -> Any:
+    test_result = apply_result.get("test_result") if isinstance(apply_result.get("test_result"), dict) else {}
+    status = _status_from_bool(test_result.get("passed"))
+    if status:
+        return status
+    for iteration in reversed(result.get("iterations") or []):
+        if isinstance(iteration, dict):
+            status = _status_from_bool(iteration.get("post_pytest_passed"))
+            if status:
+                return status
+    if code_result.get("last_status"):
+        return code_result.get("last_status")
+    return _status_from_bool(result.get("success"))
+
+
+def _rollback_path(apply_result: Dict[str, Any]) -> Any:
+    if apply_result.get("rollback_path"):
+        return apply_result.get("rollback_path")
+    backups = apply_result.get("backups") if isinstance(apply_result.get("backups"), dict) else {}
+    return backups.get("rpg") or backups.get("dep_graph") or apply_result.get("rollback_command")
+
+
+def _user_decision(result: Dict[str, Any], artifacts: Dict[str, Any]) -> UserDecisionEvent:
+    apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
+    current_head = read_head(REPO_DIR)
+    before_state = apply_result.get("before_state") if apply_result.get("before_state") else current_head
+    branch = before_state.get("head_branch") if isinstance(before_state, dict) else None
+    if not branch and isinstance(current_head, dict):
+        branch = current_head.get("head_branch")
+    confirmed = apply_result.get("confirmed") if "confirmed" in apply_result else None
+    return UserDecisionEvent(
+        decision="apply",
+        branch=branch,
+        before_state=before_state,
+        rollback_path=_rollback_path(apply_result),
+        confirmed=confirmed,
+        apply_status=_apply_status(apply_result),
+        test_status=_test_status(result, code_result, apply_result),
+    )
+
+
 class _ReportPayload:
     def __init__(self, run: CommandRun, focused_graph: Dict[str, Any]):
         self.run = run
@@ -414,6 +472,7 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
                 VerificationEvent(name=row.get("name", "verification"), status=row.get("status"), detail=row.get("detail"))
                 for row in _review_verification(result, artifacts)
             ],
+            user_decisions=[_user_decision(result, artifacts)],
             evidence=evidence,
         )
         report_path = write_command_report(_ReportPayload(report_run, focused_graph))
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 037c9cc..b0c91c0 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -86,6 +86,7 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
     plan_path = tmp_path / "plan.json"
     impact_path = tmp_path / "impact.json"
     code_path = tmp_path / "code.json"
+    apply_path = tmp_path / "apply.json"
     review_path = tmp_path / "review.json"
     report_path = tmp_path / "report.html"
     rpg_path = tmp_path / "rpg.json"
@@ -111,6 +112,27 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
         encoding="utf-8",
     )
     code_path.write_text(json.dumps({"success": True, "commit_sha": "abc123", "files_modified": ["a.py"], "last_status": "complete"}), encoding="utf-8")
+    backup_path = tmp_path / "rpg.before-edit-123.json"
+    apply_path.write_text(
+        json.dumps({
+            "type": "success",
+            "backup_timestamp": "123",
+            "backups": {"rpg": str(backup_path)},
+            "applied_features": [{"node_id": "n1", "action": "modified"}],
+            "dep_graph_refreshed": True,
+            "rollback_path": str(backup_path),
+            "rollback_command": "cmind script rpg_edit/apply.py --rollback 123",
+            "before_state": {
+                "head_commit": "before123",
+                "head_short": "before1",
+                "head_branch": "rpg-edit/test",
+                "head_timestamp": "2026-06-30T12:00:00+00:00",
+            },
+            "confirmed": True,
+            "test_result": {"passed": True, "output": ""},
+        }),
+        encoding="utf-8",
+    )
     rpg_path.write_text(
         json.dumps({
             "repo_name": "test",
@@ -129,6 +151,7 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
     monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
     monkeypatch.setattr(review, "RPG_EDIT_IMPACT_FILE", impact_path)
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
+    monkeypatch.setattr(review, "RPG_EDIT_APPLY_RESULT_FILE", apply_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
     monkeypatch.setattr(review, "REPO_RPG_FILE", rpg_path)
     monkeypatch.setattr(review, "REPORTS_DIR", tmp_path)
@@ -140,13 +163,35 @@ def fake_file_diffs_between(repo_dir, from_commit=None, to_commit="HEAD", *, fil
         return [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
 
     monkeypatch.setattr(review, "file_diffs_between", fake_file_diffs_between)
+    monkeypatch.setattr(
+        review,
+        "read_head",
+        lambda repo_dir: {
+            "head_commit": "current123",
+            "head_short": "current",
+            "head_branch": "current-branch",
+            "head_timestamp": "2026-06-30T12:30:00+00:00",
+        },
+    )
 
     def fake_write_command_report(run):
         data = run.to_dict()
         review_artifact = next(
             item for item in data["artifacts"] if item["label"] == "review_result"
         )
+        apply_artifact = next(
+            item for item in data["artifacts"] if item["label"] == "apply_result"
+        )
         assert review_artifact["status"] == "available"
+        assert apply_artifact["status"] == "available"
+        decision = data["user_decisions"][0]
+        assert decision["decision"] == "apply"
+        assert decision["branch"] == "rpg-edit/test"
+        assert decision["before_state"]["head_commit"] == "before123"
+        assert decision["rollback_path"] == str(backup_path)
+        assert decision["confirmed"] is True
+        assert decision["apply_status"] == "success"
+        assert decision["test_status"] == "passed"
         assert data["retrievals"][0]["tool"] == str(locate_path)
         assert data["retrievals"][0]["query"] == "a.py"
         assert "locate score=1.0" in data["retrievals"][0]["hits"][0]["reason"]
@@ -177,6 +222,7 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     plan_path = tmp_path / "plan.json"
     impact_path = tmp_path / "impact.json"
     code_path = tmp_path / "code.json"
+    apply_path = tmp_path / "apply.json"
     review_path = tmp_path / "review.json"
     report_path = tmp_path / "report.html"
     dep_id = "scripts/common/run_report.py:_render_artifacts"
@@ -189,16 +235,48 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
         encoding="utf-8",
     )
     code_path.write_text(json.dumps({"success": True, "files_modified": ["scripts/common/run_report.py"], "last_status": "complete"}), encoding="utf-8")
+    apply_path.write_text(
+        json.dumps({
+            "type": "dep_refreshed",
+            "backup_timestamp": "456",
+            "backups": {"dep_graph": str(tmp_path / "dep_graph.before-edit-456.json")},
+            "applied_features": [],
+            "dep_graph_refreshed": True,
+            "rollback_command": "cmind script rpg_edit/apply.py --rollback 456",
+            "test_result": {"passed": False, "output": "failing test"},
+        }),
+        encoding="utf-8",
+    )
 
     monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", validate_path)
     monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
     monkeypatch.setattr(review, "RPG_EDIT_IMPACT_FILE", impact_path)
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
+    monkeypatch.setattr(review, "RPG_EDIT_APPLY_RESULT_FILE", apply_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
     monkeypatch.setattr(review, "_focused_graph_artifact", lambda candidates, artifacts: {})
+    monkeypatch.setattr(
+        review,
+        "read_head",
+        lambda repo_dir: {
+            "head_commit": "current456",
+            "head_short": "current",
+            "head_branch": "fallback-branch",
+            "head_timestamp": "2026-06-30T13:00:00+00:00",
+        },
+    )
 
     def fake_write_command_report(run):
         data = run.to_dict()
+        decision = data["user_decisions"][0]
+        assert decision["decision"] == "apply"
+        assert decision["branch"] == "fallback-branch"
+        assert decision["before_state"]["head_commit"] == "current456"
+        assert "confirmed" not in decision
+        assert decision["apply_status"] == "dep_refreshed"
+        assert decision["test_status"] == "failed"
+        assert decision["rollback_path"].endswith("dep_graph.before-edit-456.json")
+        assert any(item["label"] == "apply_result" for item in data["artifacts"])
         assert data["rpg_deltas"] == [{"node_id": "planned", "name": "Planned Node"}]
         assert data["dep_graph_deltas"] == [
             {"dep_node_id": dep_id, "path": "scripts/common/run_report.py", "source_feature": "planned"}
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 7ffe7d5..f27ccd0 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -37,6 +37,17 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
             dep_graph_deltas=[DepGraphDeltaEvent(dep_node_id="a.py:f", path="a.py")],
             artifacts=[ArtifactEvent(label="plan", path=tmp_path / "plan.json")],
             verification=[VerificationEvent(name="pytest", status="passed")],
+            user_decisions=[
+                UserDecisionEvent(
+                    decision="apply <unsafe>",
+                    branch="rpg-edit/<branch>",
+                    before_state={"head_branch": "<main>", "head_commit": "abc<script>"},
+                    rollback_path="backup/<script>",
+                    confirmed=True,
+                    apply_status="success <ok>",
+                    test_status="passed <ok>",
+                )
+            ],
             evidence={"raw": "<script>evil()</script>"},
             timestamp="2026-06-30T12:34:56Z",
         ),
@@ -48,10 +59,24 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
     html = report.read_text(encoding="utf-8")
     assert "Summary" in html
     assert "Stage timeline" in html
+    assert "Safety boundary" in html
     assert "Artifact links" in html
     assert "Evidence JSON" in html
+    assert "Before state" in html
+    assert "Confirmation" in html
+    assert "Branch" in html
+    assert "Apply status" in html
+    assert "Test status" in html
+    assert "Rollback path" in html
+    assert "apply &lt;unsafe&gt;" in html
+    assert "rpg-edit/&lt;branch&gt;" in html
+    assert "abc&lt;script&gt;" in html
+    assert "backup/&lt;script&gt;" in html
+    assert "success &lt;ok&gt;" in html
+    assert "passed &lt;ok&gt;" in html
     assert "&lt;script&gt;evil()&lt;/script&gt;" in html
     assert "<script>alert(1)</script>" not in html
+    assert "backup/<script>" not in html
 
 
 def test_write_command_report_renders_retrievals_code_deltas_and_focused_graph(tmp_path: Path) -> None:
@@ -190,7 +215,15 @@ def test_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:
         DepGraphDeltaEvent(dep_node_id="a.py:f", path="a.py", source_feature="feature", change="modified"),
         CodeDeltaEvent(file="a.py", change_type="modify", before="old", after="new", diff="@@"),
         VerificationEvent(),
-        UserDecisionEvent(decision="apply", branch="rpg-edit/x", before_state={"clean": True}, rollback_path="backup", confirmed=True),
+        UserDecisionEvent(
+            decision="apply",
+            branch="rpg-edit/x",
+            before_state={"clean": True},
+            rollback_path="backup",
+            confirmed=True,
+            apply_status="success",
+            test_status="passed",
+        ),
         ArtifactEvent(label="artifact", path=available),
     ]
 
@@ -210,6 +243,8 @@ def test_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:
     assert run["retrievals"][0]["tool"] == "grep"
     assert run["code_deltas"][0]["file"] == "a.py"
     assert run["user_decisions"][0]["confirmed"] is True
+    assert run["user_decisions"][0]["apply_status"] == "success"
+    assert run["user_decisions"][0]["test_status"] == "passed"
     assert run["artifacts"][0]["status"] == "available"
 
 

From f54b1bf0c4f106b67cadd391b8960ec27ec814ce Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 2 Jul 2026 02:15:53 +0000
Subject: [PATCH 15/56] version: update to 0.1.10

---
 CoderMind/pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CoderMind/pyproject.toml b/CoderMind/pyproject.toml
index f73a08c..7485fd2 100644
--- a/CoderMind/pyproject.toml
+++ b/CoderMind/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "cmind-cli"
-version = "0.1.9"
+version = "0.1.10"
 description = "CoderMind CLI - A tool to generate feature trees for repository planning and code generation."
 requires-python = ">=3.12"
 dependencies = [

From 32ec402cc968db326d5783fbf770b96dedf713bf Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 2 Jul 2026 12:06:27 +0000
Subject: [PATCH 16/56] rpg_edit: Update _retrieval_hit_reason() at
 scripts/rpg_edit/review.py

---
 CoderMind/scripts/common/run_report.py      | 182 ++++++++++----
 CoderMind/scripts/rpg_edit/review.py        | 254 +++++++++++++++++---
 CoderMind/tests/test_rpg_edit_run_report.py |  35 ++-
 CoderMind/tests/test_run_report.py          |  62 ++++-
 4 files changed, 457 insertions(+), 76 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index d0bae9d..d35923e 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -52,6 +52,7 @@ def write_command_report(
     retrievals = data.get("retrievals") or evidence_data.get("retrievals")
     code_deltas = data.get("code_deltas") or evidence_data.get("code_deltas")
     focused_graph = data.get("focused_graph") or evidence_data.get("focused_graph")
+    focused_impact = data.get("focused_impact") or evidence_data.get("focused_impact")
     user_decisions = data.get("user_decisions") or evidence_data.get("user_decisions")
 
     page_title = title or f"CoderMind {command} Explain View"
@@ -67,6 +68,7 @@ def write_command_report(
         dep_nodes=_normalize_nodes(data.get("dep_graph_deltas"), dep_graph=True),
         code_deltas=_normalize_code_deltas(code_deltas),
         focused_graph=_normalize_focused_graph(focused_graph),
+        focused_impact=_normalize_focused_impact(focused_impact),
         artifacts=_normalize_artifacts(data.get("artifacts")),
         verification=_normalize_verification(data.get("verification")),
         user_decisions=_normalize_user_decisions(user_decisions),
@@ -204,6 +206,21 @@ def _normalize_focused_graph(value: Any) -> dict[str, Any]:
     return {"detail": value}
 
 
+def _normalize_focused_impact(value: Any) -> dict[str, Any]:
+    if value in (None, "", [], {}):
+        return {}
+    if not isinstance(value, Mapping):
+        return {"detail": value, "groups": []}
+    normalized = dict(value)
+    normalized["summary"] = dict(value.get("summary") or {}) if isinstance(value.get("summary"), Mapping) else {}
+    normalized["groups"] = [dict(group) if isinstance(group, Mapping) else {"detail": group} for group in _as_sequence(value.get("groups"))]
+    normalized["unmatched_code_deltas"] = [
+        dict(delta) if isinstance(delta, Mapping) else {"file": delta}
+        for delta in _as_sequence(value.get("unmatched_code_deltas"))
+    ]
+    return normalized
+
+
 def _normalize_artifacts(value: Any) -> list[dict[str, Any]]:
     artifacts: list[dict[str, Any]] = []
     for item in _as_sequence(value):
@@ -277,6 +294,7 @@ def _render_page(
     dep_nodes: list[dict[str, Any]],
     code_deltas: list[dict[str, Any]],
     focused_graph: dict[str, Any],
+    focused_impact: dict[str, Any],
     artifacts: list[dict[str, Any]],
     verification: list[dict[str, Any]],
     user_decisions: list[dict[str, Any]],
@@ -297,7 +315,7 @@ def _render_page(
 h1 {{ margin:0 0 8px; font-size:30px; }}
 .meta {{ color:var(--muted); font-size:14px; display:flex; flex-wrap:wrap; gap:12px; }}
 .status {{ border:1px solid var(--line); border-radius:999px; padding:2px 10px; background:#eef4ff; color:#174ea6; }}
-section {{ background:var(--card); border:1px solid var(--line); border-radius:14px; margin:16px 0; padding:18px; box-shadow:0 1px 2px rgba(15,23,42,.04); }}
+section {{ background:var(--card); border:1px solid var(--line); border-radius:14px; margin:16px 0; padding:18px; box-shadow:0 1px 2px rgba(15,23,42,.04); overflow-x:auto; }}
 h2 {{ margin:0 0 14px; font-size:18px; }}
 .cards {{ display:grid; grid-template-columns:repeat(auto-fit,minmax(150px,1fr)); gap:12px; }}
 .card {{ border:1px solid var(--line); border-radius:12px; padding:14px; background:#fbfdff; }}
@@ -315,7 +333,7 @@ def _render_page(
 .delta {{ border:1px solid var(--line); border-radius:12px; padding:12px; margin:10px 0; background:#fbfdff; }}
 .delta-head {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin-bottom:8px; }}
 .hit-list {{ margin:0; padding-left:18px; }}
-table {{ width:100%; border-collapse:collapse; font-size:14px; table-layout:fixed; }}
+table {{ width:100%; min-width:680px; border-collapse:collapse; font-size:14px; table-layout:auto; }}
 th, td {{ border-top:1px solid var(--line); padding:8px 10px; text-align:left; vertical-align:top; overflow-wrap:anywhere; word-break:break-word; }}
 th {{ color:var(--muted); font-weight:600; background:#fbfdff; }}
 code {{ white-space:normal; overflow-wrap:anywhere; word-break:break-word; }}
@@ -335,12 +353,10 @@ def _render_page(
 {_render_summary_cards(summary_cards)}
 {_render_timeline(stages)}
 {_render_safety_boundary(user_decisions)}
-{_render_verification(verification)}
-{_render_retrievals(retrievals)}
-{_render_node_table("Focused RPG node evidence", rpg_nodes)}
-{_render_node_table("Focused dependency node evidence", dep_nodes)}
+{_render_why_these_nodes(retrievals, rpg_nodes, dep_nodes)}
+{_render_focused_impact(focused_impact, focused_graph)}
 {_render_code_deltas(code_deltas)}
-{_render_focused_graph(focused_graph)}
+{_render_verification(verification)}
 {_render_artifacts(artifacts)}
 {_render_evidence(evidence)}
 </main>
@@ -441,9 +457,9 @@ def _render_safety_boundary(decisions: list[dict[str, Any]]) -> str:
     return f"<section><h2>Safety boundary</h2>{body}</section>"
 
 
-def _render_retrievals(retrievals: list[dict[str, Any]]) -> str:
+def _render_retrievals(retrievals: list[dict[str, Any]], *, title: str = "Retrieval evidence", as_section: bool = True) -> str:
     if not retrievals:
-        return ""
+        return "" if as_section else f"<h3>{_h(title)}</h3><p class=\"empty\">No retrieval evidence recorded.</p>"
     rows = []
     for retrieval in retrievals:
         hits = retrieval.get("hits") or []
@@ -467,7 +483,9 @@ def _render_retrievals(retrievals: list[dict[str, Any]]) -> str:
             "</tr>"
         )
     body = "<table><thead><tr><th>Tool</th><th>Query</th><th>Reason</th><th>Hits</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
-    return f"<section><h2>Retrieval evidence</h2>{body}</section>"
+    if not as_section:
+        return f"<h3>{_h(title)}</h3>{body}"
+    return f"<section><h2>{_h(title)}</h2>{body}</section>"
 
 
 def _render_code_deltas(deltas: list[dict[str, Any]]) -> str:
@@ -495,10 +513,58 @@ def _render_code_deltas(deltas: list[dict[str, Any]]) -> str:
             f"{diff_html}{before_after}"
             "</div>"
         )
-    return f"<section><h2>Code deltas</h2>{''.join(blocks)}</section>"
+    return f"<section><h2>What changed?</h2>{''.join(blocks)}</section>"
+
+
+def _render_why_these_nodes(
+    retrievals: list[dict[str, Any]],
+    rpg_nodes: list[dict[str, Any]],
+    dep_nodes: list[dict[str, Any]],
+) -> str:
+    if not retrievals and not rpg_nodes and not dep_nodes:
+        return ""
+    blocks = []
+    if retrievals:
+        blocks.append(_render_retrievals(retrievals, title="Retrieval evidence", as_section=False))
+    if rpg_nodes:
+        blocks.append(_render_node_rows("Selected feature groups", rpg_nodes, dep_graph=False))
+    if dep_nodes:
+        blocks.append(_render_node_rows("Mapped code relations", dep_nodes, dep_graph=True))
+    return f"<section><h2>Why these nodes?</h2>{''.join(blocks)}</section>"
 
 
-def _render_focused_graph(focused_graph: dict[str, Any]) -> str:
+def _render_node_rows(title: str, nodes: list[dict[str, Any]], *, dep_graph: bool) -> str:
+    if not nodes:
+        return f"<h3>{_h(title)}</h3><p class=\"empty\">No node evidence recorded.</p>"
+    rows = []
+    if dep_graph:
+        for node in nodes:
+            dep_id = node.get("dep_node_id") or node.get("node_id")
+            rows.append(
+                "<tr>"
+                f"<td><code>{_h(dep_id)}</code></td>"
+                f"<td>{_h(node.get('path', ''))}</td>"
+                f"<td><code>{_h(node.get('source_feature', ''))}</code></td>"
+                f"<td>{_h(node.get('relation') or node.get('change') or node.get('status', ''))}</td>"
+                "</tr>"
+            )
+        body = "<table><thead><tr><th>Code node</th><th>Path</th><th>Feature</th><th>Relation/state</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+    else:
+        for node in nodes:
+            rows.append(
+                "<tr>"
+                f"<td><code>{_h(node.get('node_id', ''))}</code></td>"
+                f"<td>{_h(node.get('name', ''))}</td>"
+                f"<td>{_h(node.get('type') or node.get('node_type') or '')}</td>"
+                f"<td>{_h(node.get('path', ''))}</td>"
+                f"<td>{_h(node.get('score') or node.get('status') or '')}</td>"
+                "</tr>"
+            )
+        body = "<table><thead><tr><th>Feature</th><th>Name</th><th>Type</th><th>Path</th><th>Score/state</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
+    return f"<h3>{_h(title)}</h3>{body}"
+
+
+def _focused_graph_metadata(focused_graph: dict[str, Any]) -> str:
     if not focused_graph:
         return ""
     path = focused_graph.get("path") or focused_graph.get("artifact_path") or focused_graph.get("html_path")
@@ -520,38 +586,70 @@ def _render_focused_graph(focused_graph: dict[str, Any]) -> str:
     table = "<table><tbody>" + "".join(table_rows) + "</tbody></table>" if table_rows else "<p class=\"empty\">No focused graph metadata recorded.</p>"
     metadata = json.dumps(focused_graph, indent=2, ensure_ascii=False, default=_json_default)
     inspector = f"<details><summary>Inspector metadata</summary><pre>{_h(metadata)}</pre></details>"
-    return f"<section><h2>Focused graph evidence</h2>{table}{inspector}</section>"
+    return f"<h3>Focused graph evidence</h3>{table}{inspector}"
 
 
-def _render_node_table(title: str, nodes: list[dict[str, Any]]) -> str:
-    if not nodes:
-        body = "<p class=\"empty\">No node evidence recorded.</p>"
-    elif any("dep_node_id" in node for node in nodes):
-        rows = []
-        for node in nodes:
-            rows.append(
-                "<tr>"
-                f"<td><code>{_h(node.get('dep_node_id', ''))}</code></td>"
-                f"<td>{_h(node.get('path', ''))}</td>"
-                f"<td>{_h(node.get('source_feature', ''))}</td>"
-                f"<td>{_h(node.get('change', ''))}</td>"
-                "</tr>"
-            )
-        body = "<table><thead><tr><th>ID</th><th>Path</th><th>Source feature</th><th>Change</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
-    else:
-        rows = []
-        for node in nodes:
-            rows.append(
-                "<tr>"
-                f"<td><code>{_h(node.get('node_id', ''))}</code></td>"
-                f"<td>{_h(node.get('name', ''))}</td>"
-                f"<td>{_h(node.get('type', ''))}</td>"
-                f"<td>{_h(node.get('path', ''))}</td>"
-                f"<td>{_h(node.get('score', ''))}</td>"
-                "</tr>"
-            )
-        body = "<table><thead><tr><th>ID</th><th>Name</th><th>Type</th><th>Path</th><th>Score/status</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
-    return f"<section><h2>{_h(title)}</h2>{body}</section>"
+def _render_focused_impact(focused_impact: dict[str, Any], focused_graph: dict[str, Any]) -> str:
+    if not focused_impact and not focused_graph:
+        return ""
+    summary = focused_impact.get("summary") if isinstance(focused_impact.get("summary"), Mapping) else {}
+    groups = focused_impact.get("groups") or []
+    blocks = []
+    if summary:
+        rows = "".join(f"<tr><th>{_h(key)}</th><td>{_h(value)}</td></tr>" for key, value in summary.items())
+        blocks.append("<table><tbody>" + rows + "</tbody></table>")
+    if groups:
+        for group in groups:
+            blocks.append(_render_focused_impact_group(group))
+    elif focused_impact:
+        blocks.append("<p class=\"empty\">No focused impact groups recorded.</p>")
+    blocks.append(_focused_graph_metadata(focused_graph))
+    return f"<section><h2>Focused impact summary</h2>{''.join(blocks)}</section>"
+
+
+def _render_focused_impact_group(group: Mapping[str, Any]) -> str:
+    title = group.get("name") or group.get("node_id") or "feature"
+    node_id = group.get("node_id", "")
+    missing_states = group.get("missing_states") if isinstance(group.get("missing_states"), Mapping) else {}
+    hidden_counts = group.get("hidden_counts") if isinstance(group.get("hidden_counts"), Mapping) else {}
+    relations = [item for item in _as_sequence(group.get("code_relations")) if isinstance(item, Mapping)]
+    affected_files = _as_sequence(group.get("affected_files"))
+    changed_files = _as_sequence(group.get("changed_files"))
+    state_rows = [
+        ("Feature", f"<code>{_h(node_id)}</code>", True),
+        ("Reason", _h(group.get("reason", "")), True),
+        ("Status", _h(group.get("status", "")), True),
+        ("Missing states", _h(missing_states or "none"), True),
+        ("Hidden counts", _h(hidden_counts or "none"), True),
+        ("Affected files", _h(", ".join(str(item) for item in affected_files)), True),
+        ("Changed files", _h(", ".join(str(item) for item in changed_files)), True),
+    ]
+    rows = []
+    for label, value, is_html in state_rows:
+        if value in (None, ""):
+            continue
+        rows.append(f"<tr><th>{_h(label)}</th><td>{value if is_html else _h(value)}</td></tr>")
+    relation_rows = []
+    for relation in relations:
+        dep_id = relation.get("dep_node_id") or relation.get("node_id")
+        relation_rows.append(
+            "<tr>"
+            f"<td><code>{_h(dep_id)}</code></td>"
+            f"<td>{_h(relation.get('path', ''))}</td>"
+            f"<td>{_h(relation.get('relation') or relation.get('source') or '')}</td>"
+            f"<td>{_h(relation.get('status', ''))}</td>"
+            "</tr>"
+        )
+    relations_html = "<p class=\"empty\">No mapped code relations recorded.</p>"
+    if relation_rows:
+        relations_html = "<table><thead><tr><th>Code node</th><th>Path</th><th>Relation</th><th>Status</th></tr></thead><tbody>" + "".join(relation_rows) + "</tbody></table>"
+    return (
+        "<div class=\"delta\">"
+        f"<div class=\"delta-head\"><strong>{_h(title)}</strong><code>{_h(node_id)}</code></div>"
+        "<table><tbody>" + "".join(rows) + "</tbody></table>"
+        f"<details><summary>Mapped code relations</summary>{relations_html}</details>"
+        "</div>"
+    )
 
 
 def _render_artifacts(artifacts: list[dict[str, Any]]) -> str:
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index ab8bc0e..d66ce52 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -130,11 +130,18 @@ def _selected_candidate_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
     rows: List[Dict[str, Any]] = []
     for node_id in affected:
         impact = impact_results.get(node_id) if isinstance(impact_results.get(node_id), dict) else {}
-        candidate = dict(candidates_by_id.get(node_id) or {"node_id": node_id})
+        located = candidates_by_id.get(node_id)
+        candidate = dict(located or {"node_id": node_id})
+        if located:
+            candidate.setdefault("locate_state", "selected")
+        else:
+            candidate["locate_state"] = "missing"
+            candidate["reason_state"] = "reconstructed_from_plan_impact"
         if impact:
             candidate.setdefault("name", impact.get("name", ""))
             if not candidate.get("dep_nodes"):
                 candidate["dep_nodes"] = impact.get("dep_nodes") or []
+                candidate["dep_nodes_source"] = "impact"
             if not candidate.get("status") and (impact.get("error") or impact.get("message")):
                 candidate["status"] = impact.get("error") or impact.get("message")
         rows.append(candidate)
@@ -149,24 +156,54 @@ def _listify(value: Any) -> List[Any]:
     return [value]
 
 
+def _ordered_unique(values: List[Any]) -> List[str]:
+    seen: set[str] = set()
+    ordered: List[str] = []
+    for value in values:
+        if value in (None, ""):
+            continue
+        text = str(value)
+        if text in seen:
+            continue
+        seen.add(text)
+        ordered.append(text)
+    return ordered
+
+
+def _candidate_dep_nodes(candidate: Dict[str, Any], impact: Dict[str, Any]) -> List[str]:
+    return _ordered_unique(_listify(candidate.get("dep_nodes")) + _listify(impact.get("dep_nodes")))
+
+
 def _retrieval_hit_reason(candidate: Dict[str, Any], impact: Dict[str, Any]) -> str:
     parts: List[str] = []
-    if candidate.get("score") not in (None, ""):
+    if candidate.get("locate_state") == "missing":
+        parts.append("locate missing; reconstructed from plan/impact")
+    elif candidate.get("score") not in (None, ""):
         parts.append(f"locate score={candidate.get('score')}")
+    elif candidate.get("node_id"):
+        parts.append("selected feature")
     if candidate.get("feature_path"):
         parts.append(f"feature path={candidate.get('feature_path')}")
-    dep_count = len(_listify(candidate.get("dep_nodes")))
+    dep_count = len(_candidate_dep_nodes(candidate, impact))
     if dep_count:
-        parts.append(f"{dep_count} dep nodes")
-    if impact.get("error"):
+        parts.append(f"{dep_count} mapped code relations ({dep_count} dep nodes)")
+    else:
+        parts.append("missing dep_graph mapping")
+    if not impact:
+        parts.append("missing impact result")
+    elif impact.get("error"):
         parts.append(f"impact error={impact.get('error')}")
-    if impact.get("message"):
-        parts.append(str(impact.get("message")))
+    elif impact.get("message"):
+        parts.append(f"impact state={impact.get('message')}")
     summary = impact.get("impact_summary") if isinstance(impact.get("impact_summary"), dict) else {}
     callers = summary.get("total_callers", len(impact.get("callers") or []))
+    callees = summary.get("total_callees", len(impact.get("callees") or []))
+    inheritance = summary.get("total_inheritance", len(impact.get("inheritance") or []))
     files = summary.get("affected_file_count", len(impact.get("affected_files") or []))
-    if callers or files:
+    if callers or callees or inheritance or files:
         parts.append(f"impact callers={callers}, affected_files={files}")
+        if callees or inheritance:
+            parts.append(f"impact callees={callees}, inheritance={inheritance}")
     return "; ".join(parts) or "selected by review plan"
 
 
@@ -179,32 +216,46 @@ def _retrieval_rows(artifacts: Dict[str, Any], candidates: List[Dict[str, Any]])
         for candidate in candidates:
             node_id = candidate.get("node_id")
             impact = impact_results.get(node_id) if isinstance(impact_results.get(node_id), dict) else {}
+            dep_nodes = _candidate_dep_nodes(candidate, impact)
+            locate_state = candidate.get("locate_state") or ("selected" if node_id else "missing")
+            impact_state = "available" if impact else "missing"
+            if impact.get("error"):
+                impact_state = "error"
+            elif impact and not dep_nodes:
+                impact_state = "missing_mapping"
             hits.append({
                 "node_id": node_id,
                 "name": candidate.get("name"),
                 "path": candidate.get("path") or candidate.get("meta_path"),
                 "score": candidate.get("score"),
+                "locate_state": locate_state,
+                "impact_state": impact_state,
+                "mapping_state": "mapped" if dep_nodes else "missing_mapping",
+                "mapped_code_relations": len(dep_nodes),
                 "reason": _retrieval_hit_reason(candidate, impact),
             })
         rows.append({
             "query": locate.get("query", ""),
             "tool": str(RPG_EDIT_LOCATE_FILE),
-            "reason": f"{len(hits)} selected from {len(locate.get('results') or [])} locate candidates",
+            "reason": f"{len(hits)} selected feature groups from {len(locate.get('results') or [])} locate candidates",
             "hits": hits,
         })
     if impact_results:
         hits = []
         for node_id, impact in impact_results.items():
             impact = impact if isinstance(impact, dict) else {}
+            dep_nodes = _candidate_dep_nodes({"node_id": node_id}, impact)
             hits.append({
                 "node_id": node_id,
                 "name": impact.get("name"),
+                "impact_state": "available" if dep_nodes else "missing_mapping",
+                "mapped_code_relations": len(dep_nodes),
                 "reason": _retrieval_hit_reason({"node_id": node_id}, impact),
             })
         rows.append({
             "query": ", ".join(str(node_id) for node_id in impact_results),
             "tool": str(RPG_EDIT_IMPACT_FILE),
-            "reason": f"{len(impact_results)} impact result sets",
+            "reason": f"{len(impact_results)} impact result sets with mapped code relations",
             "hits": hits,
         })
     return rows
@@ -282,30 +333,171 @@ def _dep_node_path(dep_id: Any) -> str:
     return dep_id_text.split(":", 1)[0] if ":" in dep_id_text else dep_id_text
 
 
+def _mapped_code_relations(candidate: Dict[str, Any], impact: Dict[str, Any]) -> List[Dict[str, Any]]:
+    candidate_dep = {str(dep_id) for dep_id in _listify(candidate.get("dep_nodes"))}
+    impact_dep = {str(dep_id) for dep_id in _listify(impact.get("dep_nodes"))}
+    candidate_dep_source = candidate.get("dep_nodes_source")
+    rows: List[Dict[str, Any]] = []
+    for dep_id in _candidate_dep_nodes(candidate, impact):
+        sources: List[str] = []
+        if dep_id in candidate_dep and candidate_dep_source != "impact":
+            sources.append("locate")
+        if dep_id in impact_dep or (dep_id in candidate_dep and candidate_dep_source == "impact"):
+            sources.append("impact")
+        rows.append({
+            "node_id": dep_id,
+            "dep_node_id": dep_id,
+            "source_feature": candidate.get("node_id"),
+            "path": _dep_node_path(dep_id) or candidate.get("meta_path") or candidate.get("path"),
+            "relation": "feature_to_dep",
+            "source": "+".join(sources) or "selected_feature",
+            "status": "mapped",
+        })
+    return rows
+
+
 def _dep_node_rows(candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     rows: List[Dict[str, Any]] = []
     for candidate in candidates:
-        for dep_id in candidate.get("dep_nodes") or []:
-            rows.append({
-                "node_id": dep_id,
-                "source_feature": candidate.get("node_id"),
-                "path": _dep_node_path(dep_id) or candidate.get("meta_path"),
-            })
+        rows.extend(_mapped_code_relations(candidate, {}))
     return rows
 
 
-def _review_summary_cards(result: Dict[str, Any], artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
-    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
+def _code_delta_file(delta: Dict[str, Any]) -> str:
+    return str(delta.get("file") or delta.get("path") or "")
+
+
+def _feature_evidence_groups(
+    artifacts: Dict[str, Any],
+    candidates: List[Dict[str, Any]],
+    code_deltas: List[Dict[str, Any]],
+    result: Dict[str, Any],
+    focused_graph: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
+    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
+    apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
+    impact_results = _impact_results(artifacts)
+    locate_ids = {row.get("node_id") for row in locate.get("results") or [] if isinstance(row, dict)}
+    applied_by_id = {
+        row.get("node_id"): row
+        for row in apply_result.get("applied_features") or []
+        if isinstance(row, dict) and row.get("node_id")
+    }
+    changed_files = _ordered_unique(
+        [_code_delta_file(delta) for delta in code_deltas]
+        + [str(path) for path in _listify(code_result.get("files_modified"))]
+        + [str(change.get("file_path")) for change in plan.get("code_changes") or [] if isinstance(change, dict) and change.get("file_path")]
+    )
+    groups: List[Dict[str, Any]] = []
+    for candidate in candidates:
+        node_id = candidate.get("node_id")
+        impact = impact_results.get(node_id) if isinstance(impact_results.get(node_id), dict) else {}
+        relations = _mapped_code_relations(candidate, impact)
+        relation_paths = _ordered_unique([row.get("path") for row in relations])
+        affected_files = _ordered_unique(_listify(impact.get("affected_files")) + relation_paths)
+        relevant_files = set(affected_files or relation_paths or changed_files)
+        relevant_deltas = [delta for delta in code_deltas if _code_delta_file(delta) in relevant_files]
+        locate_state = candidate.get("locate_state") or ("selected" if node_id in locate_ids or not locate else "missing")
+        if not impact:
+            impact_state = "missing"
+        elif impact.get("error"):
+            impact_state = "error"
+        elif relations:
+            impact_state = "mapped"
+        else:
+            impact_state = "missing_mapping"
+        missing_states: Dict[str, str] = {}
+        if locate_state != "selected":
+            missing_states["locate"] = str(locate_state)
+        if impact_state != "mapped":
+            missing_states["impact"] = impact_state
+        if not relations:
+            missing_states["mapping"] = "missing_dep_graph_mapping"
+        impact_summary = impact.get("impact_summary") if isinstance(impact.get("impact_summary"), dict) else {}
+        caller_count = impact_summary.get("total_callers", len(impact.get("callers") or []))
+        callee_count = impact_summary.get("total_callees", len(impact.get("callees") or []))
+        inheritance_count = impact_summary.get("total_inheritance", len(impact.get("inheritance") or []))
+        affected_file_count = impact_summary.get("affected_file_count", len(affected_files))
+        apply_row = applied_by_id.get(node_id, {})
+        groups.append({
+            "node_id": node_id,
+            "name": candidate.get("name") or impact.get("name") or node_id,
+            "node_type": candidate.get("node_type") or candidate.get("type_name") or candidate.get("type"),
+            "path": candidate.get("path") or candidate.get("meta_path"),
+            "feature_path": candidate.get("feature_path"),
+            "score": candidate.get("score"),
+            "status": "mapped" if relations else "missing_mapping",
+            "reason": _retrieval_hit_reason(candidate, impact),
+            "missing_states": missing_states,
+            "code_relations": relations,
+            "affected_files": affected_files,
+            "changed_files": [_code_delta_file(delta) for delta in relevant_deltas],
+            "callers": impact.get("callers") or [],
+            "callees": impact.get("callees") or [],
+            "imports": impact.get("imports") or [],
+            "inheritance": impact.get("inheritance") or [],
+            "hidden_counts": {
+                "code_relations": len(relations),
+                "affected_files": affected_file_count,
+                "callers": caller_count,
+                "callees": callee_count,
+                "imports": len(impact.get("imports") or []),
+                "inheritance": inheritance_count,
+            },
+            "apply": {
+                "status": _apply_status(apply_result),
+                "action": apply_row.get("action") or apply_row.get("change"),
+                "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
+            },
+            "review": {
+                "status": result.get("type", "review"),
+                "success": result.get("success", result.get("type") == "skipped"),
+                "iterations": len(result.get("iterations") or []),
+                "suggestions": len(result.get("suggestions") or []),
+            },
+        })
+    matched_files = {file_path for group in groups for file_path in group.get("changed_files") or []}
+    unmatched_code_deltas = [delta for delta in code_deltas if _code_delta_file(delta) not in matched_files]
+    summary = {
+        "selected_feature_groups": len(groups),
+        "mapped_code_relations": sum(len(group.get("code_relations") or []) for group in groups),
+        "missing_mappings": sum(1 for group in groups if not group.get("code_relations")),
+        "changed_files": len(changed_files),
+        "review_status": result.get("type", "review"),
+        "apply_status": _apply_status(apply_result),
+        "verification_status": _test_status(result, code_result, apply_result),
+    }
+    payload: Dict[str, Any] = {
+        "summary": summary,
+        "groups": groups,
+        "unmatched_code_deltas": unmatched_code_deltas,
+    }
+    if focused_graph:
+        payload["graph"] = focused_graph
+    return payload
+
+
+def _review_summary_cards(
+    result: Dict[str, Any],
+    artifacts: Dict[str, Any],
+    focused_impact: Optional[Dict[str, Any]] = None,
+) -> List[Dict[str, Any]]:
+    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
+    apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
+    summary = focused_impact.get("summary") if isinstance(focused_impact, dict) else {}
+    result_value = "passed" if result.get("success", result.get("type") == "skipped") else "failed"
+    changed_files = summary.get("changed_files", len(code_result.get("files_modified") or []))
     return [
-        {"label": "review", "value": result.get("type", "review")},
-        {"label": "success", "value": result.get("success", result.get("type") == "skipped")},
-        {"label": "iterations", "value": len(result.get("iterations") or [])},
-        {"label": "files", "value": len(code_result.get("files_modified") or [])},
-        {"label": "candidates", "value": len(locate.get("results") or [])},
-        {"label": "affected nodes", "value": len(plan.get("affected_nodes") or [])},
-        {"label": "suggestions", "value": len(result.get("suggestions") or [])},
+        {"label": "Review status", "value": result.get("type", "review")},
+        {"label": "Review result", "value": result_value},
+        {"label": "Selected features", "value": summary.get("selected_feature_groups", len(plan.get("affected_nodes") or []))},
+        {"label": "Mapped code relations", "value": summary.get("mapped_code_relations", 0)},
+        {"label": "Missing mappings", "value": summary.get("missing_mappings", 0)},
+        {"label": "Changed files", "value": changed_files},
+        {"label": "Verification", "value": summary.get("verification_status") or _test_status(result, code_result, apply_result)},
     ]
 
 
@@ -398,14 +590,17 @@ def _user_decision(result: Dict[str, Any], artifacts: Dict[str, Any]) -> UserDec
 
 
 class _ReportPayload:
-    def __init__(self, run: CommandRun, focused_graph: Dict[str, Any]):
+    def __init__(self, run: CommandRun, focused_graph: Dict[str, Any], focused_impact: Dict[str, Any]):
         self.run = run
         self.focused_graph = focused_graph
+        self.focused_impact = focused_impact
 
     def to_dict(self) -> Dict[str, Any]:
         data = self.run.to_dict()
         if self.focused_graph:
             data["focused_graph"] = self.focused_graph
+        if self.focused_impact:
+            data["focused_impact"] = self.focused_impact
         return data
 
 
@@ -415,10 +610,11 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
     candidates = _selected_candidate_rows(artifacts)
     code_deltas = _code_delta_rows(artifacts)
     focused_graph = _focused_graph_artifact(candidates, artifacts)
+    focused_impact = _feature_evidence_groups(artifacts, candidates, code_deltas, result, focused_graph)
     artifact_rows = _artifact_links(plan_path, impact_path)
     if focused_graph.get("path"):
         artifact_rows.append({"label": "focused_graph", "path": focused_graph["path"], "status": focused_graph.get("status")})
-    evidence = {"artifacts": artifacts, "review_result": result}
+    evidence = {"artifacts": artifacts, "review_result": result, "focused_impact": focused_impact}
     if focused_graph:
         evidence["focused_graph"] = focused_graph
     try:
@@ -426,7 +622,7 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
             command="rpg_edit",
             title="CoderMind rpg_edit Explain View",
             status=str(result.get("type", "review")),
-            summary=_review_summary_cards(result, artifacts),
+            summary=_review_summary_cards(result, artifacts, focused_impact),
             steps=[
                 StepEvent(name=row.get("name", "stage"), status=row.get("status"), reason=row.get("reason", ""))
                 for row in _review_timeline(result, artifacts)
@@ -475,7 +671,7 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
             user_decisions=[_user_decision(result, artifacts)],
             evidence=evidence,
         )
-        report_path = write_command_report(_ReportPayload(report_run, focused_graph))
+        report_path = write_command_report(_ReportPayload(report_run, focused_graph, focused_impact))
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index b0c91c0..943c1e1 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -202,6 +202,26 @@ def fake_write_command_report(run):
         assert data["focused_graph"]["selected_rpg_nodes"] == ["n1"]
         assert data["focused_graph"]["selected_dep_nodes"] == ["a.py:f"]
         assert Path(data["focused_graph"]["path"]).exists()
+        assert data["focused_impact"]["summary"]["selected_feature_groups"] == 1
+        assert data["focused_impact"]["summary"]["mapped_code_relations"] == 1
+        assert data["focused_impact"]["summary"]["missing_mappings"] == 0
+        focused_group = data["focused_impact"]["groups"][0]
+        assert focused_group["node_id"] == "n1"
+        assert focused_group["status"] == "mapped"
+        assert focused_group["code_relations"] == [
+            {
+                "node_id": "a.py:f",
+                "dep_node_id": "a.py:f",
+                "source_feature": "n1",
+                "path": "a.py",
+                "relation": "feature_to_dep",
+                "source": "locate+impact",
+                "status": "mapped",
+            }
+        ]
+        assert focused_group["affected_files"] == ["a.py"]
+        assert focused_group["changed_files"] == ["a.py"]
+        assert focused_group["hidden_counts"]["callers"] == 1
         assert any(item["label"] == "focused_graph" for item in data["artifacts"])
         return report_path
 
@@ -282,9 +302,22 @@ def fake_write_command_report(run):
             {"dep_node_id": dep_id, "path": "scripts/common/run_report.py", "source_feature": "planned"}
         ]
         assert data["retrievals"][0]["hits"][0]["node_id"] == "planned"
-        assert "1 dep nodes" in data["retrievals"][0]["hits"][0]["reason"]
+        assert data["retrievals"][0]["hits"][0]["locate_state"] == "missing"
+        assert data["retrievals"][0]["hits"][0]["mapping_state"] == "mapped"
+        assert "1 mapped code relations" in data["retrievals"][0]["hits"][0]["reason"]
         assert "impact callers=0, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
+        focused = data["focused_impact"]
+        assert focused["summary"]["selected_feature_groups"] == 1
+        assert focused["summary"]["mapped_code_relations"] == 1
+        assert focused["summary"]["missing_mappings"] == 0
+        group = focused["groups"][0]
+        assert group["node_id"] == "planned"
+        assert group["missing_states"] == {"locate": "missing"}
+        assert group["code_relations"][0]["dep_node_id"] == dep_id
+        assert group["code_relations"][0]["source"] == "impact"
+        assert group["changed_files"] == ["scripts/common/run_report.py"]
+        assert group["apply"]["status"] == "dep_refreshed"
         return report_path
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index f27ccd0..fb06d8d 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -57,12 +57,28 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
     assert report.parent == tmp_path
     assert report.name.startswith("cmind_run_rpg_edit_script_alert_1_script_")
     html = report.read_text(encoding="utf-8")
+    section_order = [
+        "Summary",
+        "Stage timeline",
+        "Safety boundary",
+        "Why these nodes?",
+        "Focused impact summary",
+        "What changed?",
+        "Verification status",
+        "Artifact links",
+        "Evidence JSON",
+    ]
+    positions = [html.index(title) for title in section_order if title in html]
+    assert positions == sorted(positions)
     assert "Summary" in html
     assert "Stage timeline" in html
     assert "Safety boundary" in html
+    assert "Verification status" in html
     assert "Artifact links" in html
     assert "Evidence JSON" in html
     assert "Before state" in html
+    assert "overflow-x:auto" in html
+    assert "min-width:680px" in html
     assert "Confirmation" in html
     assert "Branch" in html
     assert "Apply status" in html
@@ -108,22 +124,59 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_graph(t
                 "rpg_node_count": 2,
                 "dep_node_count": 1,
             },
+            "focused_impact": {
+                "summary": {
+                    "selected_feature_groups": 2,
+                    "mapped_code_relations": 1,
+                    "missing_mappings": 1,
+                },
+                "groups": [
+                    {
+                        "node_id": "n1<script>",
+                        "name": "Node <unsafe>",
+                        "status": "mapped",
+                        "reason": "locate score < 1",
+                        "code_relations": [
+                            {"dep_node_id": "a.py:f<script>", "path": "a.py", "relation": "feature_to_dep", "status": "mapped"}
+                        ],
+                        "affected_files": ["a.py"],
+                        "changed_files": ["a.py"],
+                        "hidden_counts": {"callers": 3, "code_relations": 1},
+                    },
+                    {
+                        "node_id": "n2",
+                        "name": "Missing mapping",
+                        "status": "missing_mapping",
+                        "reason": "missing dep_graph mapping",
+                        "code_relations": [],
+                        "missing_states": {"mapping": "missing_dep_graph_mapping"},
+                        "hidden_counts": {"code_relations": 0},
+                    },
+                ],
+            },
             "timestamp": "fixed",
         },
         report_dir=tmp_path,
     )
 
     html = report.read_text(encoding="utf-8")
+    assert "Why these nodes?" in html
     assert "Retrieval evidence" in html
-    assert "Code deltas" in html
-    assert "Focused graph evidence" in html
+    assert "What changed?" in html
+    assert "Focused impact summary" in html
     assert "RPG_EDIT_LOCATE_FILE" in html
     assert "n1&lt;script&gt;" in html
+    assert "Node &lt;unsafe&gt;" in html
+    assert "a.py:f&lt;script&gt;" in html
+    assert "missing_dep_graph_mapping" in html
+    assert "Hidden counts" in html
+    assert '"callers": 3' in html
     assert "+line 0 &lt;script&gt;alert(0)&lt;/script&gt;" in html
     assert "+line 0 <script>alert(0)</script>" not in html
     assert "<details><summary>View diff</summary>" in html
     assert "<details open" not in html
-    assert html.count("<h2>Focused graph evidence</h2>") == 1
+    assert html.count("<h2>Focused impact summary</h2>") == 1
+    assert "Focused graph evidence" in html
     assert "Graph artifact" in html
     assert "Inspector metadata" in html
 
@@ -169,7 +222,8 @@ def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Pa
     )
 
     html = report.read_text(encoding="utf-8")
-    assert html.count("No node evidence recorded.") == 2
+    assert "Why these nodes?" not in html
+    assert "Focused impact summary" not in html
     assert '"dep_nodes": 4' in html
     assert '<td><code>4</code></td>' not in html
 

From 7fb0de91105d1f5573d5f15137e1bcccc4e594de Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Fri, 3 Jul 2026 05:14:55 +0000
Subject: [PATCH 17/56] rpg_edit: Stop producing standalone focused HTML:
 remove/disable _focu

---
 CoderMind/scripts/common/run_report.py      | 276 +++++----
 CoderMind/scripts/rpg_edit/review.py        | 597 ++++++++++++++++----
 CoderMind/tests/test_rpg_edit_run_report.py | 106 ++--
 CoderMind/tests/test_run_report.py          | 126 +++--
 4 files changed, 815 insertions(+), 290 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index d35923e..7ac682e 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -51,8 +51,9 @@ def write_command_report(
     evidence_data = evidence.get("evidence") if isinstance(evidence.get("evidence"), Mapping) else {}
     retrievals = data.get("retrievals") or evidence_data.get("retrievals")
     code_deltas = data.get("code_deltas") or evidence_data.get("code_deltas")
-    focused_graph = data.get("focused_graph") or evidence_data.get("focused_graph")
-    focused_impact = data.get("focused_impact") or evidence_data.get("focused_impact")
+    focused_view = data.get("focused_view") or evidence_data.get("focused_view")
+    if not focused_view:
+        focused_view = data.get("focused_impact") or evidence_data.get("focused_impact")
     user_decisions = data.get("user_decisions") or evidence_data.get("user_decisions")
 
     page_title = title or f"CoderMind {command} Explain View"
@@ -67,8 +68,7 @@ def write_command_report(
         rpg_nodes=_normalize_nodes(data.get("rpg_deltas"), dep_graph=False),
         dep_nodes=_normalize_nodes(data.get("dep_graph_deltas"), dep_graph=True),
         code_deltas=_normalize_code_deltas(code_deltas),
-        focused_graph=_normalize_focused_graph(focused_graph),
-        focused_impact=_normalize_focused_impact(focused_impact),
+        focused_view=_normalize_focused_view(focused_view),
         artifacts=_normalize_artifacts(data.get("artifacts")),
         verification=_normalize_verification(data.get("verification")),
         user_decisions=_normalize_user_decisions(user_decisions),
@@ -198,22 +198,34 @@ def _normalize_code_deltas(value: Any) -> list[dict[str, Any]]:
     return deltas
 
 
-def _normalize_focused_graph(value: Any) -> dict[str, Any]:
-    if value in (None, "", [], {}):
-        return {}
-    if isinstance(value, Mapping):
-        return dict(value)
-    return {"detail": value}
-
-
-def _normalize_focused_impact(value: Any) -> dict[str, Any]:
+def _normalize_focused_view(value: Any) -> dict[str, Any]:
     if value in (None, "", [], {}):
         return {}
     if not isinstance(value, Mapping):
-        return {"detail": value, "groups": []}
+        return {"detail": value}
     normalized = dict(value)
     normalized["summary"] = dict(value.get("summary") or {}) if isinstance(value.get("summary"), Mapping) else {}
-    normalized["groups"] = [dict(group) if isinstance(group, Mapping) else {"detail": group} for group in _as_sequence(value.get("groups"))]
+    normalized["primary_rpg_nodes"] = [
+        dict(node) if isinstance(node, Mapping) else {"node_id": node}
+        for node in _as_sequence(value.get("primary_rpg_nodes"))
+    ]
+    normalized["primary_code_nodes"] = [
+        dict(node) if isinstance(node, Mapping) else {"node_id": node}
+        for node in _as_sequence(value.get("primary_code_nodes"))
+    ]
+    normalized["mappings"] = [
+        dict(mapping) if isinstance(mapping, Mapping) else {"detail": mapping}
+        for mapping in _as_sequence(value.get("mappings"))
+    ]
+    normalized["edges"] = [
+        dict(edge) if isinstance(edge, Mapping) else {"detail": edge}
+        for edge in _as_sequence(value.get("edges"))
+    ]
+    normalized["hidden_counts"] = dict(value.get("hidden_counts") or {}) if isinstance(value.get("hidden_counts"), Mapping) else {}
+    normalized["warnings"] = [
+        dict(warning) if isinstance(warning, Mapping) else {"message": warning}
+        for warning in _as_sequence(value.get("warnings"))
+    ]
     normalized["unmatched_code_deltas"] = [
         dict(delta) if isinstance(delta, Mapping) else {"file": delta}
         for delta in _as_sequence(value.get("unmatched_code_deltas"))
@@ -293,8 +305,7 @@ def _render_page(
     rpg_nodes: list[dict[str, Any]],
     dep_nodes: list[dict[str, Any]],
     code_deltas: list[dict[str, Any]],
-    focused_graph: dict[str, Any],
-    focused_impact: dict[str, Any],
+    focused_view: dict[str, Any],
     artifacts: list[dict[str, Any]],
     verification: list[dict[str, Any]],
     user_decisions: list[dict[str, Any]],
@@ -342,6 +353,9 @@ def _render_page(
 .empty {{ color:var(--muted); font-style:italic; }}
 pre {{ white-space:pre-wrap; overflow:auto; background:#0f172a; color:#e5e7eb; border-radius:10px; padding:14px; }}
 details summary {{ cursor:pointer; color:var(--accent); font-weight:600; }}
+.focus-summary {{ display:flex; flex-wrap:wrap; gap:8px; margin-bottom:12px; }}
+.focus-summary .badge {{ background:#eef4ff; color:#174ea6; }}
+.warning-list {{ margin:0 0 12px; padding-left:18px; }}
 </style>
 </head>
 <body>
@@ -354,7 +368,7 @@ def _render_page(
 {_render_timeline(stages)}
 {_render_safety_boundary(user_decisions)}
 {_render_why_these_nodes(retrievals, rpg_nodes, dep_nodes)}
-{_render_focused_impact(focused_impact, focused_graph)}
+{_render_focused_impact(focused_view)}
 {_render_code_deltas(code_deltas)}
 {_render_verification(verification)}
 {_render_artifacts(artifacts)}
@@ -564,94 +578,164 @@ def _render_node_rows(title: str, nodes: list[dict[str, Any]], *, dep_graph: boo
     return f"<h3>{_h(title)}</h3>{body}"
 
 
-def _focused_graph_metadata(focused_graph: dict[str, Any]) -> str:
-    if not focused_graph:
-        return ""
-    path = focused_graph.get("path") or focused_graph.get("artifact_path") or focused_graph.get("html_path")
-    href = _artifact_href(path) if path else "#"
-    rows = [
-        ("Status", focused_graph.get("status", "recorded"), False),
-        ("Graph artifact", f"<a href=\"{_h_attr(href)}\">{_h(path or '')}</a>" if path else "", True),
-        ("Selected RPG nodes", ", ".join(str(v) for v in focused_graph.get("selected_rpg_nodes") or focused_graph.get("rpg_node_ids") or []), False),
-        ("Selected dependency nodes", ", ".join(str(v) for v in focused_graph.get("selected_dep_nodes") or focused_graph.get("dep_node_ids") or []), False),
-        ("Included RPG nodes", focused_graph.get("rpg_node_count") or focused_graph.get("rpg_nodes") or "", False),
-        ("Included dependency nodes", focused_graph.get("dep_node_count") or focused_graph.get("dep_nodes") or "", False),
-    ]
-    table_rows = []
-    for label, value, is_html in rows:
-        if value in (None, ""):
-            continue
-        rendered = str(value) if is_html else _h(value)
-        table_rows.append(f"<tr><th>{_h(label)}</th><td>{rendered}</td></tr>")
-    table = "<table><tbody>" + "".join(table_rows) + "</tbody></table>" if table_rows else "<p class=\"empty\">No focused graph metadata recorded.</p>"
-    metadata = json.dumps(focused_graph, indent=2, ensure_ascii=False, default=_json_default)
-    inspector = f"<details><summary>Inspector metadata</summary><pre>{_h(metadata)}</pre></details>"
-    return f"<h3>Focused graph evidence</h3>{table}{inspector}"
-
-
-def _render_focused_impact(focused_impact: dict[str, Any], focused_graph: dict[str, Any]) -> str:
-    if not focused_impact and not focused_graph:
-        return ""
-    summary = focused_impact.get("summary") if isinstance(focused_impact.get("summary"), Mapping) else {}
-    groups = focused_impact.get("groups") or []
-    blocks = []
-    if summary:
-        rows = "".join(f"<tr><th>{_h(key)}</th><td>{_h(value)}</td></tr>" for key, value in summary.items())
-        blocks.append("<table><tbody>" + rows + "</tbody></table>")
-    if groups:
-        for group in groups:
-            blocks.append(_render_focused_impact_group(group))
-    elif focused_impact:
-        blocks.append("<p class=\"empty\">No focused impact groups recorded.</p>")
-    blocks.append(_focused_graph_metadata(focused_graph))
-    return f"<section><h2>Focused impact summary</h2>{''.join(blocks)}</section>"
+def _focused_graph_metadata(focused_view: dict[str, Any]) -> str:
+    data = json.dumps(focused_view, indent=2, ensure_ascii=False, default=_json_default)
+    return f"<details><summary>Inspector JSON</summary><pre>{_h(data)}</pre></details>"
 
 
-def _render_focused_impact_group(group: Mapping[str, Any]) -> str:
-    title = group.get("name") or group.get("node_id") or "feature"
-    node_id = group.get("node_id", "")
-    missing_states = group.get("missing_states") if isinstance(group.get("missing_states"), Mapping) else {}
-    hidden_counts = group.get("hidden_counts") if isinstance(group.get("hidden_counts"), Mapping) else {}
-    relations = [item for item in _as_sequence(group.get("code_relations")) if isinstance(item, Mapping)]
-    affected_files = _as_sequence(group.get("affected_files"))
-    changed_files = _as_sequence(group.get("changed_files"))
-    state_rows = [
-        ("Feature", f"<code>{_h(node_id)}</code>", True),
-        ("Reason", _h(group.get("reason", "")), True),
-        ("Status", _h(group.get("status", "")), True),
-        ("Missing states", _h(missing_states or "none"), True),
-        ("Hidden counts", _h(hidden_counts or "none"), True),
-        ("Affected files", _h(", ".join(str(item) for item in affected_files)), True),
-        ("Changed files", _h(", ".join(str(item) for item in changed_files)), True),
+def _focused_node_cell(node_id: Any, node: Mapping[str, Any] | None) -> str:
+    if node_id in (None, "") and not node:
+        return "<span class=\"empty\">missing</span>"
+    node = node or {}
+    parts = []
+    if node_id not in (None, ""):
+        parts.append(f"<code>{_h(node_id)}</code>")
+    if node.get("name"):
+        parts.append(f"<div>{_h(node.get('name'))}</div>")
+    if node.get("path"):
+        parts.append(f"<div class=\"reason\">{_h(node.get('path'))}</div>")
+    return "".join(parts) or "<span class=\"empty\">missing</span>"
+
+
+def _render_focused_impact(focused_view: dict[str, Any]) -> str:
+    if not focused_view:
+        return ""
+    summary = focused_view.get("summary") if isinstance(focused_view.get("summary"), Mapping) else {}
+    rpg_nodes = [node for node in _as_sequence(focused_view.get("primary_rpg_nodes")) if isinstance(node, Mapping)]
+    code_nodes = [node for node in _as_sequence(focused_view.get("primary_code_nodes")) if isinstance(node, Mapping)]
+    mappings = [mapping for mapping in _as_sequence(focused_view.get("mappings")) if isinstance(mapping, Mapping)]
+    edges = [edge for edge in _as_sequence(focused_view.get("edges")) if isinstance(edge, Mapping)]
+    hidden_counts = focused_view.get("hidden_counts") if isinstance(focused_view.get("hidden_counts"), Mapping) else {}
+    warnings = [warning for warning in _as_sequence(focused_view.get("warnings")) if isinstance(warning, Mapping)]
+    rpg_by_id = {str(node.get("node_id")): node for node in rpg_nodes if node.get("node_id") not in (None, "")}
+    code_by_id = {
+        str(node.get("node_id") or node.get("dep_node_id")): node
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+    summary_items = [
+        ("Primary RPG nodes", summary.get("primary_rpg_nodes", len(rpg_nodes))),
+        ("Primary code nodes", summary.get("primary_code_nodes", len(code_nodes))),
+        ("Mapped relations", summary.get("mapped_code_relations", len([row for row in mappings if row.get("code_node_id")]))),
+        ("Missing mappings", summary.get("missing_mappings", len([row for row in mappings if row.get("status") == "missing"]))),
+        ("Edges shown", summary.get("edges", len(edges))),
+        ("Warnings", summary.get("warnings", len(warnings))),
     ]
-    rows = []
-    for label, value, is_html in state_rows:
-        if value in (None, ""):
-            continue
-        rows.append(f"<tr><th>{_h(label)}</th><td>{value if is_html else _h(value)}</td></tr>")
-    relation_rows = []
-    for relation in relations:
-        dep_id = relation.get("dep_node_id") or relation.get("node_id")
-        relation_rows.append(
+    summary_html = "<div class=\"focus-summary\">" + "".join(
+        f"<span class=\"badge\">{_h(label)}: <strong>{_h(value)}</strong></span>"
+        for label, value in summary_items
+    ) + "</div>"
+
+    code_rows = []
+    for node in code_nodes:
+        node_id = node.get("node_id") or node.get("dep_node_id")
+        code_rows.append(
+            "<tr>"
+            f"<td>{_focused_node_cell(node_id, node)}</td>"
+            f"<td>{_h(node.get('type') or node.get('kind') or '')}</td>"
+            f"<td>{_h(node.get('status', ''))}</td>"
+            f"<td>{_h(node.get('source', ''))}</td>"
+            "</tr>"
+        )
+    code_html = "<p class=\"empty\">No primary code nodes recorded.</p>"
+    if code_rows:
+        code_html = "<table><thead><tr><th>Code node</th><th>Type</th><th>Status</th><th>Source</th></tr></thead><tbody>" + "".join(code_rows) + "</tbody></table>"
+
+    mapping_rows = []
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        rpg_node = rpg_by_id.get(str(rpg_id)) if rpg_id not in (None, "") else None
+        code_node = code_by_id.get(str(code_id)) if code_id not in (None, "") else None
+        changed_files = ", ".join(str(item) for item in _as_sequence(mapping.get("changed_files")))
+        mapping_rows.append(
             "<tr>"
-            f"<td><code>{_h(dep_id)}</code></td>"
-            f"<td>{_h(relation.get('path', ''))}</td>"
-            f"<td>{_h(relation.get('relation') or relation.get('source') or '')}</td>"
-            f"<td>{_h(relation.get('status', ''))}</td>"
+            f"<td>{_focused_node_cell(rpg_id, rpg_node)}</td>"
+            f"<td>{_focused_node_cell(code_id, code_node)}</td>"
+            f"<td>{_h(mapping.get('status', ''))}</td>"
+            f"<td>{_h(mapping.get('path') or (code_node or {}).get('path') or '')}</td>"
+            f"<td>{_h(mapping.get('source', ''))}</td>"
+            f"<td>{_h(mapping.get('reason', ''))}</td>"
+            f"<td>{_h(changed_files)}</td>"
             "</tr>"
         )
-    relations_html = "<p class=\"empty\">No mapped code relations recorded.</p>"
-    if relation_rows:
-        relations_html = "<table><thead><tr><th>Code node</th><th>Path</th><th>Relation</th><th>Status</th></tr></thead><tbody>" + "".join(relation_rows) + "</tbody></table>"
+    mappings_html = "<p class=\"empty\">No semantic-code mappings recorded.</p>"
+    if mapping_rows:
+        mappings_html = (
+            "<table><thead><tr><th>Semantic node</th><th>Code node</th><th>Status</th>"
+            "<th>Path</th><th>Source</th><th>Reason</th><th>Changed files</th></tr></thead><tbody>"
+            + "".join(mapping_rows)
+            + "</tbody></table>"
+        )
+
+    hidden_relations = hidden_counts.get("relations") if isinstance(hidden_counts.get("relations"), Mapping) else {}
+    relation_hidden_keys = {"caller": "callers", "callee": "callees", "import": "imports", "inheritance": "inheritance"}
+    edges_by_relation: dict[str, list[Mapping[str, Any]]] = {}
+    for edge in edges:
+        relation = str(edge.get("relation") or "dependency")
+        edges_by_relation.setdefault(relation, []).append(edge)
+    relation_names = set(edges_by_relation)
+    for relation, hidden_key in relation_hidden_keys.items():
+        if hidden_counts.get(hidden_key):
+            relation_names.add(relation)
+    relation_blocks = []
+    for relation in sorted(relation_names):
+        hidden = hidden_relations.get(relation, 0) if isinstance(hidden_relations, Mapping) else 0
+        hidden += hidden_counts.get(relation_hidden_keys.get(relation, ""), 0) or 0
+        relation_blocks.append(_render_focused_impact_group({"relation": relation, "edges": edges_by_relation.get(relation, []), "hidden": hidden}))
+    neighborhood_html = "".join(relation_blocks) or "<p class=\"empty\">No one-hop neighborhood edges recorded.</p>"
+
+    warning_html = "<p class=\"empty\">No focused warnings recorded.</p>"
+    if warnings:
+        warning_items = []
+        for warning in warnings:
+            warning_type = warning.get("type", "warning")
+            context = {key: value for key, value in warning.items() if key not in {"type", "message"}}
+            context_html = f" <code>{_h(context)}</code>" if context else ""
+            warning_items.append(f"<li><code>{_h(warning_type)}</code> {_h(warning.get('message', ''))}{context_html}</li>")
+        warning_html = '<ul class="warning-list">' + "".join(warning_items) + "</ul>"
+
+    hidden_html = "<p class=\"empty\">No hidden focused context recorded.</p>"
+    if hidden_counts:
+        hidden_rows = "".join(f"<tr><th>{_h(key)}</th><td>{_h(value)}</td></tr>" for key, value in hidden_counts.items())
+        hidden_html = "<table><tbody>" + hidden_rows + "</tbody></table>"
+
     return (
-        "<div class=\"delta\">"
-        f"<div class=\"delta-head\"><strong>{_h(title)}</strong><code>{_h(node_id)}</code></div>"
-        "<table><tbody>" + "".join(rows) + "</tbody></table>"
-        f"<details><summary>Mapped code relations</summary>{relations_html}</details>"
-        "</div>"
+        "<section><h2>Focused impact view</h2>"
+        f"{summary_html}"
+        f"<h3>Primary code nodes</h3>{code_html}"
+        f"<h3>Semantic-code mappings</h3>{mappings_html}"
+        f"<h3>Capped neighborhood</h3>{neighborhood_html}"
+        f"<h3>Warnings</h3>{warning_html}"
+        f"<h3>Hidden context</h3>{hidden_html}"
+        f"{_focused_graph_metadata(focused_view)}"
+        "</section>"
     )
 
 
+def _render_focused_impact_group(group: Mapping[str, Any]) -> str:
+    relation = group.get("relation") or "dependency"
+    edges = [edge for edge in _as_sequence(group.get("edges")) if isinstance(edge, Mapping)]
+    hidden = group.get("hidden") or 0
+    edge_rows = []
+    for edge in edges:
+        edge_rows.append(
+            "<tr>"
+            f"<td><code>{_h(edge.get('source_node_id', ''))}</code></td>"
+            f"<td><code>{_h(edge.get('target_node_id', ''))}</code></td>"
+            f"<td>{_h(edge.get('direction', ''))}</td>"
+            f"<td>{_h(edge.get('path', ''))}</td>"
+            f"<td>{_h(edge.get('source', ''))}</td>"
+            f"<td>{_h(edge.get('reason', ''))}</td>"
+            "</tr>"
+        )
+    rows_html = "<p class=\"empty\">No visible rows for this relation.</p>"
+    if edge_rows:
+        rows_html = "<table><thead><tr><th>Source</th><th>Target</th><th>Direction</th><th>Path</th><th>Source</th><th>Reason</th></tr></thead><tbody>" + "".join(edge_rows) + "</tbody></table>"
+    hidden_html = f"<p class=\"reason\">Hidden { _h(hidden) } additional {_h(relation)} neighbors.</p>" if hidden else ""
+    return f"<details><summary>{_h(relation)} neighborhood ({_h(len(edges))} shown)</summary>{hidden_html}{rows_html}</details>"
+
+
 def _render_artifacts(artifacts: list[dict[str, Any]]) -> str:
     if not artifacts:
         body = "<p class=\"empty\">No artifact links recorded.</p>"
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index d66ce52..6368a3d 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -283,47 +283,17 @@ def _code_delta_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
     return rows
 
 
-def _focused_graph_output_path() -> Path:
-    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
-    return REPORTS_DIR / f"rpg_edit_focused_graph_{time.time_ns()}.html"
-
-
 def _focused_graph_artifact(candidates: List[Dict[str, Any]], artifacts: Dict[str, Any]) -> Dict[str, Any]:
     dep_rows = _dep_node_rows(candidates)
     selected_rpg = sorted({str(row.get("node_id")) for row in candidates if row.get("node_id")})
     selected_dep = sorted({str(row.get("node_id")) for row in dep_rows if row.get("node_id")})
     if not selected_rpg and not selected_dep:
         return {}
-
-    metadata: Dict[str, Any] = {
-        "status": "recorded",
+    return {
+        "status": "embedded",
         "selected_rpg_nodes": selected_rpg,
         "selected_dep_nodes": selected_dep,
     }
-    rpg_data = _load_json_artifact(REPO_RPG_FILE)
-    if not isinstance(rpg_data, dict):
-        metadata.update({"status": "missing", "reason": f"RPG file not available: {REPO_RPG_FILE}"})
-        return metadata
-
-    try:
-        from rpg_visualize import build_focused_graph_data, generate_html
-
-        focused_data = build_focused_graph_data(
-            rpg_data,
-            rpg_node_ids=selected_rpg,
-            dep_node_ids=selected_dep,
-        )
-        focused_meta = focused_data.get("_focused_graph") if isinstance(focused_data.get("_focused_graph"), dict) else {}
-        metadata.update(focused_meta)
-        if not (focused_meta.get("matched_rpg_nodes") or focused_meta.get("matched_dep_nodes")):
-            metadata.update({"status": "unavailable", "reason": "selected nodes not found in current RPG"})
-            return metadata
-        graph_path = _focused_graph_output_path()
-        graph_path.write_text(generate_html(focused_data), encoding="utf-8")
-        metadata.update({"status": "available", "path": str(graph_path)})
-    except Exception as exc:
-        metadata.update({"status": "error", "reason": str(exc)})
-    return metadata
 
 
 def _dep_node_path(dep_id: Any) -> str:
@@ -367,6 +337,176 @@ def _code_delta_file(delta: Dict[str, Any]) -> str:
     return str(delta.get("file") or delta.get("path") or "")
 
 
+_FOCUSED_RPG_NODE_CAP = 20
+_FOCUSED_CODE_NODE_CAP = 50
+_FOCUSED_EDGE_CAP = 80
+_FOCUSED_WARNING_TYPES = {"missing_mapping", "missing_reason", "too_many_neighbors", "stale_graph"}
+
+
+def _set_if_present(row: Dict[str, Any], key: str, value: Any) -> None:
+    if value not in (None, ""):
+        row[key] = value
+
+
+def _focus_reason(candidate: Dict[str, Any], impact: Dict[str, Any]) -> str:
+    for source in (candidate, impact):
+        for key in ("reason", "hit_reason", "rationale", "explanation"):
+            value = source.get(key) if isinstance(source, dict) else None
+            if value not in (None, ""):
+                return str(value)
+    return ""
+
+
+def _rpg_node_entry(node_id: str, raw: Dict[str, Any]) -> Dict[str, Any]:
+    meta = raw.get("meta") if isinstance(raw.get("meta"), dict) else {}
+    row: Dict[str, Any] = {"node_id": node_id}
+    _set_if_present(row, "name", raw.get("name"))
+    _set_if_present(row, "node_type", raw.get("node_type") or raw.get("type") or raw.get("type_name"))
+    _set_if_present(row, "path", raw.get("path") or raw.get("file") or meta.get("path"))
+    _set_if_present(row, "feature_path", raw.get("feature_path") or meta.get("feature_path"))
+    return row
+
+
+def _dep_node_entry(dep_id: str, raw: Dict[str, Any]) -> Dict[str, Any]:
+    row: Dict[str, Any] = {"node_id": dep_id, "dep_node_id": dep_id}
+    for key in (
+        "name",
+        "type",
+        "kind",
+        "module",
+        "path",
+        "file",
+        "signature",
+        "line_start",
+        "line_end",
+        "start_line",
+        "end_line",
+        "lineno",
+        "line",
+    ):
+        _set_if_present(row, key, raw.get(key))
+    if not row.get("path"):
+        _set_if_present(row, "path", row.get("module") or row.get("file") or _dep_node_path(dep_id))
+    return row
+
+
+def _coerce_dep_edge(edge: Any) -> Optional[Dict[str, Any]]:
+    if isinstance(edge, dict):
+        source = edge.get("source") or edge.get("from") or edge.get("caller") or edge.get("src")
+        target = edge.get("target") or edge.get("to") or edge.get("callee") or edge.get("dst")
+        relation = edge.get("relation") or edge.get("type") or edge.get("edge_type") or edge.get("kind") or "dep_graph"
+        if source in (None, "") or target in (None, ""):
+            return None
+        row = {"source_node_id": str(source), "target_node_id": str(target), "relation": str(relation), "source": "dep_graph"}
+        _set_if_present(row, "reason", edge.get("reason"))
+        return row
+    if isinstance(edge, (list, tuple)) and len(edge) >= 2:
+        relation = edge[2] if len(edge) >= 3 else "dep_graph"
+        return {"source_node_id": str(edge[0]), "target_node_id": str(edge[1]), "relation": str(relation), "source": "dep_graph"}
+    return None
+
+
+def _current_rpg_context() -> Tuple[
+    Dict[str, Dict[str, Any]],
+    Dict[str, Dict[str, Any]],
+    List[Dict[str, Any]],
+    Dict[str, List[str]],
+    Dict[str, List[str]],
+    List[Dict[str, Any]],
+]:
+    rpg_data = _load_json_artifact(REPO_RPG_FILE)
+    if not isinstance(rpg_data, dict) or rpg_data.get("_error"):
+        return {}, {}, [], {}, {}, [{"type": "stale_graph", "message": f"RPG file not available: {REPO_RPG_FILE}"}]
+
+    rpg_nodes: Dict[str, Dict[str, Any]] = {}
+
+    def visit_rpg_node(raw: Any) -> None:
+        if not isinstance(raw, dict):
+            return
+        node_id = raw.get("id") or raw.get("node_id")
+        if node_id not in (None, ""):
+            rpg_nodes[str(node_id)] = _rpg_node_entry(str(node_id), raw)
+        children = raw.get("children") or []
+        if isinstance(children, dict):
+            children = list(children.values())
+        if isinstance(children, (list, tuple)):
+            for child in children:
+                visit_rpg_node(child)
+
+    visit_rpg_node(rpg_data.get("root"))
+    raw_rpg_nodes = rpg_data.get("nodes")
+    if isinstance(raw_rpg_nodes, dict):
+        for node_id, raw in raw_rpg_nodes.items():
+            raw_dict = raw if isinstance(raw, dict) else {}
+            rpg_nodes[str(node_id)] = _rpg_node_entry(str(node_id), raw_dict)
+    elif isinstance(raw_rpg_nodes, (list, tuple)):
+        for raw in raw_rpg_nodes:
+            if isinstance(raw, dict):
+                node_id = raw.get("id") or raw.get("node_id")
+                if node_id not in (None, ""):
+                    rpg_nodes[str(node_id)] = _rpg_node_entry(str(node_id), raw)
+
+    dep_graph = rpg_data.get("dep_graph") if isinstance(rpg_data.get("dep_graph"), dict) else {}
+    dep_nodes: Dict[str, Dict[str, Any]] = {}
+    dep_to_rpg: Dict[str, List[str]] = {}
+    rpg_to_dep: Dict[str, List[str]] = {}
+    raw_dep_nodes = dep_graph.get("nodes")
+    if isinstance(raw_dep_nodes, dict):
+        dep_items = raw_dep_nodes.items()
+    elif isinstance(raw_dep_nodes, (list, tuple)):
+        dep_items = []
+        for raw in raw_dep_nodes:
+            if isinstance(raw, dict):
+                dep_id = raw.get("id") or raw.get("node_id") or raw.get("dep_node_id")
+                if dep_id not in (None, ""):
+                    dep_items.append((dep_id, raw))
+    else:
+        dep_items = []
+    for dep_id, raw in dep_items:
+        dep_id_text = str(dep_id)
+        raw_dict = raw if isinstance(raw, dict) else {}
+        dep_nodes[dep_id_text] = _dep_node_entry(dep_id_text, raw_dict)
+        linked = _ordered_unique([str(item) for item in _listify(raw_dict.get("rpg_nodes") or raw_dict.get("features") or raw_dict.get("source_features"))])
+        if linked:
+            dep_to_rpg[dep_id_text] = linked
+            for rpg_id in linked:
+                rpg_to_dep.setdefault(rpg_id, []).append(dep_id_text)
+
+    raw_dep_to_rpg = rpg_data.get("_dep_to_rpg_map") if isinstance(rpg_data.get("_dep_to_rpg_map"), dict) else {}
+    for dep_id, rpg_ids in raw_dep_to_rpg.items():
+        dep_id_text = str(dep_id)
+        linked = _ordered_unique([str(item) for item in _listify(rpg_ids)])
+        if linked:
+            dep_to_rpg[dep_id_text] = _ordered_unique((dep_to_rpg.get(dep_id_text) or []) + linked)
+            for rpg_id in linked:
+                rpg_to_dep.setdefault(rpg_id, []).append(dep_id_text)
+
+    raw_rpg_to_dep = rpg_data.get("_rpg_to_dep_map") if isinstance(rpg_data.get("_rpg_to_dep_map"), dict) else {}
+    for rpg_id, dep_ids in raw_rpg_to_dep.items():
+        rpg_id_text = str(rpg_id)
+        linked = _ordered_unique([str(item) for item in _listify(dep_ids)])
+        if linked:
+            rpg_to_dep[rpg_id_text] = _ordered_unique((rpg_to_dep.get(rpg_id_text) or []) + linked)
+            for dep_id in linked:
+                dep_to_rpg.setdefault(dep_id, []).append(rpg_id_text)
+
+    for rpg_id, dep_ids in list(rpg_to_dep.items()):
+        rpg_to_dep[rpg_id] = _ordered_unique(dep_ids)
+    for dep_id, rpg_ids in list(dep_to_rpg.items()):
+        dep_to_rpg[dep_id] = _ordered_unique(rpg_ids)
+
+    dep_edges = []
+    for raw_edge in dep_graph.get("edges") or []:
+        edge = _coerce_dep_edge(raw_edge)
+        if edge:
+            dep_edges.append(edge)
+
+    warnings: List[Dict[str, Any]] = []
+    if not rpg_nodes and not dep_nodes:
+        warnings.append({"type": "stale_graph", "message": "Current RPG contains no indexed feature or dependency nodes"})
+    return rpg_nodes, dep_nodes, dep_edges, rpg_to_dep, dep_to_rpg, warnings
+
+
 def _feature_evidence_groups(
     artifacts: Dict[str, Any],
     candidates: List[Dict[str, Any]],
@@ -379,9 +519,11 @@ def _feature_evidence_groups(
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
     apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
     impact_results = _impact_results(artifacts)
-    locate_ids = {row.get("node_id") for row in locate.get("results") or [] if isinstance(row, dict)}
+    current_rpg_nodes, current_dep_nodes, current_dep_edges, current_rpg_to_dep, _, graph_warnings = _current_rpg_context()
+    current_graph_available = bool(current_rpg_nodes or current_dep_nodes)
+    locate_ids = {str(row.get("node_id")) for row in locate.get("results") or [] if isinstance(row, dict) and row.get("node_id")}
     applied_by_id = {
-        row.get("node_id"): row
+        str(row.get("node_id")): row
         for row in apply_result.get("applied_features") or []
         if isinstance(row, dict) and row.get("node_id")
     }
@@ -390,104 +532,327 @@ def _feature_evidence_groups(
         + [str(path) for path in _listify(code_result.get("files_modified"))]
         + [str(change.get("file_path")) for change in plan.get("code_changes") or [] if isinstance(change, dict) and change.get("file_path")]
     )
-    groups: List[Dict[str, Any]] = []
+    warnings: List[Dict[str, Any]] = []
+    warning_keys: set[str] = set()
+
+    def add_warning(warning_type: str, message: str, **context: Any) -> None:
+        if warning_type not in _FOCUSED_WARNING_TYPES:
+            return
+        row: Dict[str, Any] = {"type": warning_type, "message": message}
+        for key, value in context.items():
+            _set_if_present(row, key, value)
+        key = json.dumps(row, sort_keys=True, default=str)
+        if key not in warning_keys:
+            warning_keys.add(key)
+            warnings.append(row)
+
+    for warning in graph_warnings:
+        if isinstance(warning, dict):
+            add_warning(str(warning.get("type") or "stale_graph"), str(warning.get("message") or "Current RPG graph may be stale"))
+
+    if apply_result and apply_result.get("dep_graph_refreshed") is False:
+        add_warning("stale_graph", "Apply result says the dependency graph was not refreshed", apply_status=_apply_status(apply_result))
+
+    primary_rpg_nodes_all: List[Dict[str, Any]] = []
+    mapping_rows_all: List[Dict[str, Any]] = []
+    code_node_by_id: Dict[str, Dict[str, Any]] = {}
+    all_edges: List[Dict[str, Any]] = []
+    edge_keys: set[Tuple[str, str, str, str]] = set()
+    impact_hidden_counts: Dict[str, int] = {}
+
+    def count_value(value: Any, fallback: int) -> int:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return fallback
+
+    def add_code_node(dep_id: Any, *, source_feature: Any = None, source: str = "mapping", fallback_path: Any = None) -> None:
+        if dep_id in (None, ""):
+            return
+        dep_id_text = str(dep_id)
+        if dep_id_text in code_node_by_id:
+            row = code_node_by_id[dep_id_text]
+            row["source"] = "+".join(_ordered_unique(_listify(row.get("source")) + [source]))
+            if source_feature not in (None, ""):
+                row["source_features"] = _ordered_unique(_listify(row.get("source_features")) + [str(source_feature)])
+            return
+        current = current_dep_nodes.get(dep_id_text, {})
+        row = dict(current) if current else {"node_id": dep_id_text, "dep_node_id": dep_id_text}
+        row.setdefault("node_id", dep_id_text)
+        row.setdefault("dep_node_id", dep_id_text)
+        _set_if_present(row, "path", fallback_path)
+        row["status"] = "mapped"
+        row["source"] = source
+        if source_feature not in (None, ""):
+            row["source_feature"] = str(source_feature)
+            row["source_features"] = [str(source_feature)]
+        if row.get("path") in changed_files:
+            row["changed"] = True
+        if current_graph_available and dep_id_text not in current_dep_nodes:
+            row["status"] = "stale_graph"
+            add_warning("stale_graph", "Mapped code node is absent from the current dependency graph", dep_node_id=dep_id_text)
+        code_node_by_id[dep_id_text] = row
+
+    def add_edge(edge: Dict[str, Any]) -> None:
+        source_node = edge.get("source_node_id")
+        target_node = edge.get("target_node_id")
+        relation = edge.get("relation") or "dependency"
+        source = edge.get("source") or "impact"
+        if source_node in (None, "") or target_node in (None, ""):
+            return
+        source_text = str(source_node)
+        target_text = str(target_node)
+        relation_text = str(relation)
+        source_text_label = str(source)
+        key = (source_text, target_text, relation_text, source_text_label)
+        if key in edge_keys:
+            return
+        edge_keys.add(key)
+        row: Dict[str, Any] = {
+            "source_node_id": source_text,
+            "target_node_id": target_text,
+            "relation": relation_text,
+            "source": source_text_label,
+        }
+        for key_name in ("rpg_node_id", "neighbor_node_id", "direction", "name", "path", "reason", "status"):
+            _set_if_present(row, key_name, edge.get(key_name))
+        all_edges.append(row)
+
+    def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
+        if isinstance(item, dict):
+            node_id = item.get("dep_node_id") or item.get("node_id") or item.get("id")
+            if node_id in (None, ""):
+                return None
+            row: Dict[str, Any] = {"node_id": str(node_id)}
+            for key_name in ("name", "path", "reason", "status", "type"):
+                _set_if_present(row, key_name, item.get(key_name))
+            return row
+        if item in (None, ""):
+            return None
+        return {"node_id": str(item)}
+
+    neighbor_specs = [
+        ("callers", "caller", "upstream", "total_callers"),
+        ("callees", "callee", "downstream", "total_callees"),
+        ("imports", "import", "downstream", "total_imports"),
+        ("inheritance", "inheritance", "downstream", "total_inheritance"),
+    ]
+
     for candidate in candidates:
-        node_id = candidate.get("node_id")
+        raw_node_id = candidate.get("node_id")
+        if raw_node_id in (None, ""):
+            continue
+        node_id = str(raw_node_id)
         impact = impact_results.get(node_id) if isinstance(impact_results.get(node_id), dict) else {}
+        current_node = current_rpg_nodes.get(node_id, {})
         relations = _mapped_code_relations(candidate, impact)
-        relation_paths = _ordered_unique([row.get("path") for row in relations])
+        relation_by_dep = {str(row.get("dep_node_id") or row.get("node_id")): row for row in relations if row.get("dep_node_id") or row.get("node_id")}
+        mapped_dep_ids = _ordered_unique(list(relation_by_dep) + (current_rpg_to_dep.get(node_id) or []))
+        relation_paths = _ordered_unique(
+            [row.get("path") for row in relations]
+            + [current_dep_nodes.get(dep_id, {}).get("path") for dep_id in mapped_dep_ids]
+        )
         affected_files = _ordered_unique(_listify(impact.get("affected_files")) + relation_paths)
         relevant_files = set(affected_files or relation_paths or changed_files)
         relevant_deltas = [delta for delta in code_deltas if _code_delta_file(delta) in relevant_files]
-        locate_state = candidate.get("locate_state") or ("selected" if node_id in locate_ids or not locate else "missing")
-        if not impact:
-            impact_state = "missing"
-        elif impact.get("error"):
-            impact_state = "error"
-        elif relations:
-            impact_state = "mapped"
-        else:
-            impact_state = "missing_mapping"
-        missing_states: Dict[str, str] = {}
-        if locate_state != "selected":
-            missing_states["locate"] = str(locate_state)
-        if impact_state != "mapped":
-            missing_states["impact"] = impact_state
-        if not relations:
-            missing_states["mapping"] = "missing_dep_graph_mapping"
+        changed_for_node = _ordered_unique([_code_delta_file(delta) for delta in relevant_deltas])
+        focus_reason = _focus_reason(candidate, impact)
+        if not focus_reason:
+            add_warning("missing_reason", "Focused view has no explicit selection reason", node_id=node_id)
+        if not mapped_dep_ids:
+            add_warning("missing_mapping", "Selected RPG node has no mapped code node", node_id=node_id)
+        if current_graph_available and node_id not in current_rpg_nodes:
+            add_warning("stale_graph", "Selected RPG node is absent from the current RPG graph", node_id=node_id)
+
         impact_summary = impact.get("impact_summary") if isinstance(impact.get("impact_summary"), dict) else {}
-        caller_count = impact_summary.get("total_callers", len(impact.get("callers") or []))
-        callee_count = impact_summary.get("total_callees", len(impact.get("callees") or []))
-        inheritance_count = impact_summary.get("total_inheritance", len(impact.get("inheritance") or []))
-        affected_file_count = impact_summary.get("affected_file_count", len(affected_files))
+        node_hidden_counts: Dict[str, int] = {}
+        for impact_key, relation, direction, total_key in neighbor_specs:
+            items = _listify(impact.get(impact_key))
+            total = count_value(impact_summary.get(total_key), len(items))
+            visible = 0
+            for item in items:
+                neighbor = impact_neighbor(item)
+                if not neighbor:
+                    continue
+                visible += 1
+                if relation == "caller":
+                    source_node = neighbor["node_id"]
+                    target_node = node_id
+                else:
+                    source_node = node_id
+                    target_node = neighbor["node_id"]
+                edge_row = {
+                    "source_node_id": source_node,
+                    "target_node_id": target_node,
+                    "relation": relation,
+                    "source": "impact",
+                    "rpg_node_id": node_id,
+                    "neighbor_node_id": neighbor["node_id"],
+                    "direction": direction,
+                }
+                for key_name in ("name", "path", "reason", "status"):
+                    _set_if_present(edge_row, key_name, neighbor.get(key_name))
+                add_edge(edge_row)
+            hidden = max(0, total - visible)
+            if hidden:
+                node_hidden_counts[impact_key] = hidden
+                impact_hidden_counts[impact_key] = impact_hidden_counts.get(impact_key, 0) + hidden
+
         apply_row = applied_by_id.get(node_id, {})
-        groups.append({
+        rpg_row: Dict[str, Any] = {
             "node_id": node_id,
-            "name": candidate.get("name") or impact.get("name") or node_id,
-            "node_type": candidate.get("node_type") or candidate.get("type_name") or candidate.get("type"),
-            "path": candidate.get("path") or candidate.get("meta_path"),
-            "feature_path": candidate.get("feature_path"),
-            "score": candidate.get("score"),
-            "status": "mapped" if relations else "missing_mapping",
-            "reason": _retrieval_hit_reason(candidate, impact),
-            "missing_states": missing_states,
-            "code_relations": relations,
-            "affected_files": affected_files,
-            "changed_files": [_code_delta_file(delta) for delta in relevant_deltas],
-            "callers": impact.get("callers") or [],
-            "callees": impact.get("callees") or [],
-            "imports": impact.get("imports") or [],
-            "inheritance": impact.get("inheritance") or [],
-            "hidden_counts": {
-                "code_relations": len(relations),
-                "affected_files": affected_file_count,
-                "callers": caller_count,
-                "callees": callee_count,
-                "imports": len(impact.get("imports") or []),
-                "inheritance": inheritance_count,
-            },
-            "apply": {
-                "status": _apply_status(apply_result),
-                "action": apply_row.get("action") or apply_row.get("change"),
-                "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
-            },
-            "review": {
-                "status": result.get("type", "review"),
-                "success": result.get("success", result.get("type") == "skipped"),
-                "iterations": len(result.get("iterations") or []),
-                "suggestions": len(result.get("suggestions") or []),
-            },
-        })
-    matched_files = {file_path for group in groups for file_path in group.get("changed_files") or []}
+            "status": "mapped" if mapped_dep_ids else "missing",
+            "mapping_status": "mapped" if mapped_dep_ids else "missing",
+        }
+        _set_if_present(rpg_row, "name", candidate.get("name") or impact.get("name") or current_node.get("name"))
+        _set_if_present(rpg_row, "node_type", candidate.get("node_type") or candidate.get("type_name") or candidate.get("type") or current_node.get("node_type"))
+        _set_if_present(rpg_row, "path", candidate.get("path") or candidate.get("meta_path") or current_node.get("path"))
+        _set_if_present(rpg_row, "feature_path", candidate.get("feature_path") or current_node.get("feature_path"))
+        _set_if_present(rpg_row, "score", candidate.get("score"))
+        _set_if_present(rpg_row, "reason", focus_reason)
+        if node_id not in locate_ids and locate:
+            rpg_row["locate_status"] = candidate.get("locate_state") or "missing"
+        if affected_files:
+            rpg_row["affected_files"] = affected_files
+        if changed_for_node:
+            rpg_row["changed_files"] = changed_for_node
+        if node_hidden_counts:
+            rpg_row["hidden_counts"] = node_hidden_counts
+        _set_if_present(rpg_row, "apply_action", apply_row.get("action") or apply_row.get("change"))
+        primary_rpg_nodes_all.append(rpg_row)
+
+        if mapped_dep_ids:
+            for dep_id in mapped_dep_ids:
+                relation = relation_by_dep.get(dep_id, {})
+                current_dep = current_dep_nodes.get(dep_id, {})
+                path = current_dep.get("path") or relation.get("path")
+                source_parts = _ordered_unique(_listify(relation.get("source")) + (["current_rpg"] if dep_id in (current_rpg_to_dep.get(node_id) or []) else []))
+                mapping_status = "mapped"
+                if current_graph_available and dep_id not in current_dep_nodes:
+                    mapping_status = "stale_graph"
+                    add_warning("stale_graph", "Mapped code node is absent from the current dependency graph", node_id=node_id, dep_node_id=dep_id)
+                mapping_row: Dict[str, Any] = {
+                    "rpg_node_id": node_id,
+                    "code_node_id": dep_id,
+                    "dep_node_id": dep_id,
+                    "status": mapping_status,
+                    "source": "+".join(source_parts) or "selected_feature",
+                }
+                _set_if_present(mapping_row, "path", path)
+                _set_if_present(mapping_row, "reason", focus_reason)
+                if changed_for_node:
+                    mapping_row["changed_files"] = changed_for_node
+                mapping_rows_all.append(mapping_row)
+                add_code_node(dep_id, source_feature=node_id, source=mapping_row["source"], fallback_path=path)
+        else:
+            mapping_row = {"rpg_node_id": node_id, "status": "missing"}
+            _set_if_present(mapping_row, "reason", focus_reason)
+            if changed_for_node:
+                mapping_row["changed_files"] = changed_for_node
+            mapping_rows_all.append(mapping_row)
+
+    for dep_id, dep_node in current_dep_nodes.items():
+        if dep_node.get("path") in changed_files:
+            add_code_node(dep_id, source="changed_file", fallback_path=dep_node.get("path"))
+
+    selected_code_ids = set(code_node_by_id)
+    for edge in current_dep_edges:
+        if edge.get("source_node_id") in selected_code_ids or edge.get("target_node_id") in selected_code_ids:
+            add_edge(edge)
+
+    primary_rpg_nodes = primary_rpg_nodes_all[:_FOCUSED_RPG_NODE_CAP]
+    primary_code_nodes_all = list(code_node_by_id.values())
+    primary_code_nodes = primary_code_nodes_all[:_FOCUSED_CODE_NODE_CAP]
+    visible_rpg_ids = {row.get("node_id") for row in primary_rpg_nodes}
+    visible_code_ids = {row.get("node_id") for row in primary_code_nodes}
+    mappings = [
+        row for row in mapping_rows_all
+        if row.get("rpg_node_id") in visible_rpg_ids and (not row.get("code_node_id") or row.get("code_node_id") in visible_code_ids)
+    ]
+    edges = all_edges[:_FOCUSED_EDGE_CAP]
+    hidden_counts: Dict[str, Any] = {
+        "primary_rpg_nodes": max(0, len(primary_rpg_nodes_all) - len(primary_rpg_nodes)),
+        "primary_code_nodes": max(0, len(primary_code_nodes_all) - len(primary_code_nodes)),
+        "edges": max(0, len(all_edges) - len(edges)),
+    }
+    for key, count in impact_hidden_counts.items():
+        hidden_counts[key] = hidden_counts.get(key, 0) + count
+    relation_totals: Dict[str, int] = {}
+    relation_visible: Dict[str, int] = {}
+    for edge in all_edges:
+        relation = str(edge.get("relation") or "dependency")
+        relation_totals[relation] = relation_totals.get(relation, 0) + 1
+    for edge in edges:
+        relation = str(edge.get("relation") or "dependency")
+        relation_visible[relation] = relation_visible.get(relation, 0) + 1
+    hidden_relations = {
+        relation: total - relation_visible.get(relation, 0)
+        for relation, total in relation_totals.items()
+        if total > relation_visible.get(relation, 0)
+    }
+    if hidden_relations:
+        hidden_counts["relations"] = hidden_relations
+    capped_hidden = {
+        key: value for key, value in hidden_counts.items()
+        if key in {"primary_rpg_nodes", "primary_code_nodes", "edges"} and value
+    }
+    if capped_hidden:
+        add_warning("too_many_neighbors", "Focused view omitted rows because caps were reached", hidden_counts=capped_hidden)
+
+    matched_files = {file_path for node in primary_rpg_nodes_all for file_path in node.get("changed_files") or []}
     unmatched_code_deltas = [delta for delta in code_deltas if _code_delta_file(delta) not in matched_files]
+    mapped_code_relations = sum(1 for row in mapping_rows_all if row.get("code_node_id"))
+    missing_mappings = sum(1 for row in mapping_rows_all if row.get("status") == "missing")
     summary = {
-        "selected_feature_groups": len(groups),
-        "mapped_code_relations": sum(len(group.get("code_relations") or []) for group in groups),
-        "missing_mappings": sum(1 for group in groups if not group.get("code_relations")),
+        "selected_feature_groups": len(primary_rpg_nodes_all),
+        "primary_rpg_nodes": len(primary_rpg_nodes),
+        "primary_code_nodes": len(primary_code_nodes),
+        "mapped_code_relations": mapped_code_relations,
+        "missing_mappings": missing_mappings,
+        "edges": len(edges),
+        "warnings": len(warnings),
         "changed_files": len(changed_files),
         "review_status": result.get("type", "review"),
         "apply_status": _apply_status(apply_result),
         "verification_status": _test_status(result, code_result, apply_result),
     }
-    payload: Dict[str, Any] = {
+    return {
         "summary": summary,
-        "groups": groups,
+        "primary_rpg_nodes": primary_rpg_nodes,
+        "primary_code_nodes": primary_code_nodes,
+        "mappings": mappings,
+        "edges": edges,
+        "hidden_counts": hidden_counts,
+        "warnings": warnings,
+        "changed_files": changed_files,
         "unmatched_code_deltas": unmatched_code_deltas,
+        "caps": {
+            "primary_rpg_nodes": _FOCUSED_RPG_NODE_CAP,
+            "primary_code_nodes": _FOCUSED_CODE_NODE_CAP,
+            "edges": _FOCUSED_EDGE_CAP,
+        },
+        "apply": {
+            "status": _apply_status(apply_result),
+            "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
+        },
+        "review": {
+            "status": result.get("type", "review"),
+            "success": result.get("success", result.get("type") == "skipped"),
+            "iterations": len(result.get("iterations") or []),
+            "suggestions": len(result.get("suggestions") or []),
+        },
     }
-    if focused_graph:
-        payload["graph"] = focused_graph
-    return payload
 
 
 def _review_summary_cards(
     result: Dict[str, Any],
     artifacts: Dict[str, Any],
-    focused_impact: Optional[Dict[str, Any]] = None,
+    focused_view: Optional[Dict[str, Any]] = None,
 ) -> List[Dict[str, Any]]:
     plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
     apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
-    summary = focused_impact.get("summary") if isinstance(focused_impact, dict) else {}
+    summary = focused_view.get("summary") if isinstance(focused_view, dict) else {}
     result_value = "passed" if result.get("success", result.get("type") == "skipped") else "failed"
     changed_files = summary.get("changed_files", len(code_result.get("files_modified") or []))
     return [
@@ -590,17 +955,14 @@ def _user_decision(result: Dict[str, Any], artifacts: Dict[str, Any]) -> UserDec
 
 
 class _ReportPayload:
-    def __init__(self, run: CommandRun, focused_graph: Dict[str, Any], focused_impact: Dict[str, Any]):
+    def __init__(self, run: CommandRun, focused_view: Dict[str, Any]):
         self.run = run
-        self.focused_graph = focused_graph
-        self.focused_impact = focused_impact
+        self.focused_view = focused_view
 
     def to_dict(self) -> Dict[str, Any]:
         data = self.run.to_dict()
-        if self.focused_graph:
-            data["focused_graph"] = self.focused_graph
-        if self.focused_impact:
-            data["focused_impact"] = self.focused_impact
+        if self.focused_view:
+            data["focused_view"] = self.focused_view
         return data
 
 
@@ -609,20 +971,15 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
     artifacts = _load_review_artifacts(plan_path, impact_path)
     candidates = _selected_candidate_rows(artifacts)
     code_deltas = _code_delta_rows(artifacts)
-    focused_graph = _focused_graph_artifact(candidates, artifacts)
-    focused_impact = _feature_evidence_groups(artifacts, candidates, code_deltas, result, focused_graph)
+    focused_view = _feature_evidence_groups(artifacts, candidates, code_deltas, result)
     artifact_rows = _artifact_links(plan_path, impact_path)
-    if focused_graph.get("path"):
-        artifact_rows.append({"label": "focused_graph", "path": focused_graph["path"], "status": focused_graph.get("status")})
-    evidence = {"artifacts": artifacts, "review_result": result, "focused_impact": focused_impact}
-    if focused_graph:
-        evidence["focused_graph"] = focused_graph
+    evidence = {"artifacts": artifacts, "review_result": result, "focused_view": focused_view}
     try:
         report_run = CommandRun(
             command="rpg_edit",
             title="CoderMind rpg_edit Explain View",
             status=str(result.get("type", "review")),
-            summary=_review_summary_cards(result, artifacts, focused_impact),
+            summary=_review_summary_cards(result, artifacts, focused_view),
             steps=[
                 StepEvent(name=row.get("name", "stage"), status=row.get("status"), reason=row.get("reason", ""))
                 for row in _review_timeline(result, artifacts)
@@ -671,7 +1028,7 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
             user_decisions=[_user_decision(result, artifacts)],
             evidence=evidence,
         )
-        report_path = write_command_report(_ReportPayload(report_run, focused_graph, focused_impact))
+        report_path = write_command_report(_ReportPayload(report_run, focused_view))
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 943c1e1..a5f0008 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -93,10 +93,17 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
 
     validate_path.write_text(json.dumps({"type": "ready"}), encoding="utf-8")
     locate_path.write_text(
-        json.dumps({"type": "candidates", "query": "a.py", "results": [{"node_id": "n1", "name": "Node", "score": 1.0, "dep_nodes": ["a.py:f"]}]}),
+        json.dumps({
+            "type": "candidates",
+            "query": "a.py",
+            "results": [
+                {"node_id": "n1", "name": "Node", "score": 1.0, "dep_nodes": ["a.py:f"]},
+                {"node_id": "n2", "name": "Missing Node", "score": 0.5},
+            ],
+        }),
         encoding="utf-8",
     )
-    plan_path.write_text(json.dumps({"affected_nodes": ["n1"], "code_changes": [{"file_path": "a.py"}]}), encoding="utf-8")
+    plan_path.write_text(json.dumps({"affected_nodes": ["n1", "n2"], "code_changes": [{"file_path": "a.py"}]}), encoding="utf-8")
     impact_path.write_text(
         json.dumps({
             "type": "impact",
@@ -106,6 +113,11 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
                     "dep_nodes": ["a.py:f"],
                     "affected_files": ["a.py"],
                     "impact_summary": {"total_callers": 1, "affected_file_count": 1},
+                },
+                "n2": {
+                    "name": "Missing Node",
+                    "affected_files": [],
+                    "impact_summary": {"total_callers": 0, "affected_file_count": 0},
                 }
             },
         }),
@@ -136,7 +148,15 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
     rpg_path.write_text(
         json.dumps({
             "repo_name": "test",
-            "root": {"id": "n1", "name": "Node", "node_type": "feature", "meta": {"path": "a.py"}, "children": []},
+            "root": {
+                "id": "n1",
+                "name": "Node",
+                "node_type": "feature",
+                "meta": {"path": "a.py"},
+                "children": [
+                    {"id": "n2", "name": "Missing Node", "node_type": "feature", "meta": {"path": "b.py"}, "children": []}
+                ],
+            },
             "edges": [],
             "dep_graph": {
                 "nodes": {"a.py:f": {"name": "f", "type": "function", "module": "a.py", "rpg_nodes": ["n1"]}},
@@ -198,31 +218,26 @@ def fake_write_command_report(run):
         assert "impact callers=1, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
         assert data["code_deltas"] == [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
-        assert data["focused_graph"]["status"] == "available"
-        assert data["focused_graph"]["selected_rpg_nodes"] == ["n1"]
-        assert data["focused_graph"]["selected_dep_nodes"] == ["a.py:f"]
-        assert Path(data["focused_graph"]["path"]).exists()
-        assert data["focused_impact"]["summary"]["selected_feature_groups"] == 1
-        assert data["focused_impact"]["summary"]["mapped_code_relations"] == 1
-        assert data["focused_impact"]["summary"]["missing_mappings"] == 0
-        focused_group = data["focused_impact"]["groups"][0]
-        assert focused_group["node_id"] == "n1"
-        assert focused_group["status"] == "mapped"
-        assert focused_group["code_relations"] == [
-            {
-                "node_id": "a.py:f",
-                "dep_node_id": "a.py:f",
-                "source_feature": "n1",
-                "path": "a.py",
-                "relation": "feature_to_dep",
-                "source": "locate+impact",
-                "status": "mapped",
-            }
-        ]
-        assert focused_group["affected_files"] == ["a.py"]
-        assert focused_group["changed_files"] == ["a.py"]
-        assert focused_group["hidden_counts"]["callers"] == 1
-        assert any(item["label"] == "focused_graph" for item in data["artifacts"])
+        assert "focused_graph" not in data
+        assert "focused_impact" not in data
+        assert not any(item["label"] == "focused_graph" for item in data["artifacts"])
+        assert not list(tmp_path.glob("rpg_edit_focused_graph_*.html"))
+        focused = data["focused_view"]
+        assert focused["summary"]["selected_feature_groups"] == 2
+        assert focused["summary"]["mapped_code_relations"] == 1
+        assert focused["summary"]["missing_mappings"] == 1
+        assert focused["primary_rpg_nodes"][0]["node_id"] == "n1"
+        assert focused["primary_rpg_nodes"][0]["mapping_status"] == "mapped"
+        assert focused["primary_rpg_nodes"][0]["changed_files"] == ["a.py"]
+        assert focused["primary_rpg_nodes"][0]["hidden_counts"]["callers"] == 1
+        assert focused["primary_code_nodes"][0]["node_id"] == "a.py:f"
+        assert focused["primary_code_nodes"][0]["path"] == "a.py"
+        mapping_statuses = {row["status"] for row in focused["mappings"]}
+        assert {"mapped", "missing"}.issubset(mapping_statuses)
+        mapped = next(row for row in focused["mappings"] if row.get("code_node_id") == "a.py:f")
+        assert mapped["rpg_node_id"] == "n1"
+        assert mapped["changed_files"] == ["a.py"]
+        assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in focused["warnings"])
         return report_path
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
@@ -245,6 +260,7 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     apply_path = tmp_path / "apply.json"
     review_path = tmp_path / "review.json"
     report_path = tmp_path / "report.html"
+    rpg_path = tmp_path / "rpg.json"
     dep_id = "scripts/common/run_report.py:_render_artifacts"
 
     validate_path.write_text(json.dumps({"type": "ready"}), encoding="utf-8")
@@ -267,6 +283,19 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
         }),
         encoding="utf-8",
     )
+    rpg_path.write_text(
+        json.dumps({
+            "repo_name": "test",
+            "root": {"id": "planned", "name": "Planned Node", "node_type": "feature", "meta": {"path": "scripts/common/run_report.py"}, "children": []},
+            "edges": [],
+            "dep_graph": {
+                "nodes": {dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "rpg_nodes": ["planned"]}},
+                "edges": [],
+            },
+            "_dep_to_rpg_map": {dep_id: ["planned"]},
+        }),
+        encoding="utf-8",
+    )
 
     monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", validate_path)
     monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", locate_path)
@@ -274,7 +303,7 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", code_path)
     monkeypatch.setattr(review, "RPG_EDIT_APPLY_RESULT_FILE", apply_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
-    monkeypatch.setattr(review, "_focused_graph_artifact", lambda candidates, artifacts: {})
+    monkeypatch.setattr(review, "REPO_RPG_FILE", rpg_path)
     monkeypatch.setattr(
         review,
         "read_head",
@@ -307,17 +336,20 @@ def fake_write_command_report(run):
         assert "1 mapped code relations" in data["retrievals"][0]["hits"][0]["reason"]
         assert "impact callers=0, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
-        focused = data["focused_impact"]
+        assert "focused_graph" not in data
+        assert not any(item["label"] == "focused_graph" for item in data["artifacts"])
+        focused = data["focused_view"]
         assert focused["summary"]["selected_feature_groups"] == 1
         assert focused["summary"]["mapped_code_relations"] == 1
         assert focused["summary"]["missing_mappings"] == 0
-        group = focused["groups"][0]
-        assert group["node_id"] == "planned"
-        assert group["missing_states"] == {"locate": "missing"}
-        assert group["code_relations"][0]["dep_node_id"] == dep_id
-        assert group["code_relations"][0]["source"] == "impact"
-        assert group["changed_files"] == ["scripts/common/run_report.py"]
-        assert group["apply"]["status"] == "dep_refreshed"
+        primary = focused["primary_rpg_nodes"][0]
+        assert primary["node_id"] == "planned"
+        assert primary["locate_status"] == "missing"
+        assert primary["changed_files"] == ["scripts/common/run_report.py"]
+        mapping = focused["mappings"][0]
+        assert mapping["code_node_id"] == dep_id
+        assert "impact" in mapping["source"]
+        assert focused["apply"]["status"] == "dep_refreshed"
         return report_path
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index fb06d8d..c2fe4e3 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -62,7 +62,7 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
         "Stage timeline",
         "Safety boundary",
         "Why these nodes?",
-        "Focused impact summary",
+        "Focused impact view",
         "What changed?",
         "Verification status",
         "Artifact links",
@@ -95,9 +95,7 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
     assert "backup/<script>" not in html
 
 
-def test_write_command_report_renders_retrievals_code_deltas_and_focused_graph(tmp_path: Path) -> None:
-    graph = tmp_path / "focused.html"
-    graph.write_text("graph", encoding="utf-8")
+def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tmp_path: Path) -> None:
     long_diff = "diff --git a/a.py b/a.py\n" + "\n".join(
         f"+line {i} <script>alert({i})</script>" for i in range(40)
     )
@@ -116,43 +114,76 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_graph(t
             "code_deltas": [
                 CodeDeltaEvent(file="a.py", change_type="modify", diff=long_diff).to_dict()
             ],
-            "focused_graph": {
-                "path": graph,
-                "status": "available",
-                "selected_rpg_nodes": ["n1"],
-                "selected_dep_nodes": ["a.py:f"],
-                "rpg_node_count": 2,
-                "dep_node_count": 1,
-            },
-            "focused_impact": {
+            "focused_view": {
                 "summary": {
-                    "selected_feature_groups": 2,
+                    "primary_rpg_nodes": 2,
+                    "primary_code_nodes": 1,
                     "mapped_code_relations": 1,
                     "missing_mappings": 1,
+                    "edges": 2,
+                    "warnings": 4,
                 },
-                "groups": [
+                "primary_rpg_nodes": [
                     {
                         "node_id": "n1<script>",
                         "name": "Node <unsafe>",
+                        "path": "feature/<unsafe>",
+                        "status": "mapped",
+                        "reason": "selected <reason>",
+                        "hidden_counts": {"callers": 3},
+                    },
+                    {"node_id": "n2", "name": "Missing <mapping>", "status": "missing", "path": "missing/<path>"},
+                ],
+                "primary_code_nodes": [
+                    {
+                        "node_id": "a.py:f<script>",
+                        "dep_node_id": "a.py:f<script>",
+                        "name": "func <unsafe>",
+                        "path": "a.py<script>",
+                        "type": "function",
+                        "status": "mapped",
+                        "source": "locate<unsafe>",
+                    }
+                ],
+                "mappings": [
+                    {
+                        "rpg_node_id": "n1<script>",
+                        "code_node_id": "a.py:f<script>",
                         "status": "mapped",
-                        "reason": "locate score < 1",
-                        "code_relations": [
-                            {"dep_node_id": "a.py:f<script>", "path": "a.py", "relation": "feature_to_dep", "status": "mapped"}
-                        ],
-                        "affected_files": ["a.py"],
+                        "path": "a.py<script>",
+                        "source": "locate+impact",
+                        "reason": "maps because <reason>",
                         "changed_files": ["a.py"],
-                        "hidden_counts": {"callers": 3, "code_relations": 1},
+                    },
+                    {"rpg_node_id": "n2", "status": "missing", "reason": "no dep <reason>"},
+                ],
+                "edges": [
+                    {
+                        "source_node_id": "caller<script>",
+                        "target_node_id": "n1<script>",
+                        "relation": "caller",
+                        "direction": "upstream",
+                        "path": "caller.py<script>",
+                        "source": "impact",
+                        "reason": "calls <reason>",
                     },
                     {
-                        "node_id": "n2",
-                        "name": "Missing mapping",
-                        "status": "missing_mapping",
-                        "reason": "missing dep_graph mapping",
-                        "code_relations": [],
-                        "missing_states": {"mapping": "missing_dep_graph_mapping"},
-                        "hidden_counts": {"code_relations": 0},
+                        "source_node_id": "n1<script>",
+                        "target_node_id": "callee<script>",
+                        "relation": "callee",
+                        "direction": "downstream",
+                        "path": "callee.py<script>",
+                        "source": "impact",
+                        "reason": "reaches <reason>",
                     },
                 ],
+                "hidden_counts": {"callers": 3, "edges": 1, "relations": {"caller": 1}},
+                "warnings": [
+                    {"type": "missing_mapping", "message": "Missing <mapping>", "node_id": "n2"},
+                    {"type": "missing_reason", "message": "Missing <reason>", "node_id": "n3"},
+                    {"type": "too_many_neighbors", "message": "Too many <neighbors>", "hidden_counts": {"edges": 1}},
+                    {"type": "stale_graph", "message": "Stale <graph>", "dep_node_id": "old.py:f"},
+                ],
             },
             "timestamp": "fixed",
         },
@@ -163,22 +194,43 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_graph(t
     assert "Why these nodes?" in html
     assert "Retrieval evidence" in html
     assert "What changed?" in html
-    assert "Focused impact summary" in html
+    assert "Focused impact view" in html
+    assert html.count("<h2>Focused impact view</h2>") == 1
     assert "RPG_EDIT_LOCATE_FILE" in html
+    assert "Primary RPG nodes" in html
+    assert "Primary code nodes" in html
+    assert "Semantic-code mappings" in html
+    assert "Capped neighborhood" in html
+    assert "Hidden context" in html
+    assert "Inspector JSON" in html
+    assert "mapped" in html
+    assert "missing" in html
     assert "n1&lt;script&gt;" in html
     assert "Node &lt;unsafe&gt;" in html
+    assert "feature/&lt;unsafe&gt;" in html
     assert "a.py:f&lt;script&gt;" in html
-    assert "missing_dep_graph_mapping" in html
-    assert "Hidden counts" in html
-    assert '"callers": 3' in html
+    assert "a.py&lt;script&gt;" in html
+    assert "maps because &lt;reason&gt;" in html
+    assert "Missing &lt;mapping&gt;" in html
+    assert "missing_mapping" in html
+    assert "missing_reason" in html
+    assert "too_many_neighbors" in html
+    assert "stale_graph" in html
+    assert "Hidden 4 additional caller neighbors." in html
+    assert '"caller": 1' in html
+    assert '"focused_view"' in html
     assert "+line 0 &lt;script&gt;alert(0)&lt;/script&gt;" in html
     assert "+line 0 <script>alert(0)</script>" not in html
+    assert "Node <unsafe>" not in html
+    assert "a.py<script>" not in html
+    assert "maps because <reason>" not in html
     assert "<details><summary>View diff</summary>" in html
     assert "<details open" not in html
-    assert html.count("<h2>Focused impact summary</h2>") == 1
-    assert "Focused graph evidence" in html
-    assert "Graph artifact" in html
-    assert "Inspector metadata" in html
+    assert "Focused impact summary" not in html
+    assert "Focused graph evidence" not in html
+    assert "Graph artifact" not in html
+    assert "Inspector metadata" not in html
+    assert "focused_graph" not in html
 
 
 def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
@@ -223,7 +275,7 @@ def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Pa
 
     html = report.read_text(encoding="utf-8")
     assert "Why these nodes?" not in html
-    assert "Focused impact summary" not in html
+    assert "Focused impact view" not in html
     assert '"dep_nodes": 4' in html
     assert '<td><code>4</code></td>' not in html
 

From 137d12f540a6439aa77ef6622b7820871d5acd7a Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Fri, 3 Jul 2026 06:19:47 +0000
Subject: [PATCH 18/56] rpg_edit: At write_command_report() lines 50-56, stop
 sourcing code_de

---
 CoderMind/scripts/common/run_report.py      | 578 +++++++++++++++-----
 CoderMind/scripts/rpg_edit/review.py        | 129 ++++-
 CoderMind/tests/test_rpg_edit_run_report.py |  59 ++
 CoderMind/tests/test_run_report.py          |  32 +-
 4 files changed, 649 insertions(+), 149 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 7ac682e..cd3df68 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -50,10 +50,8 @@ def write_command_report(
     evidence = dict(data)
     evidence_data = evidence.get("evidence") if isinstance(evidence.get("evidence"), Mapping) else {}
     retrievals = data.get("retrievals") or evidence_data.get("retrievals")
-    code_deltas = data.get("code_deltas") or evidence_data.get("code_deltas")
-    focused_view = data.get("focused_view") or evidence_data.get("focused_view")
-    if not focused_view:
-        focused_view = data.get("focused_impact") or evidence_data.get("focused_impact")
+    code_deltas = data.get("code_deltas")
+    focused_view = data.get("focused_view")
     user_decisions = data.get("user_decisions") or evidence_data.get("user_decisions")
 
     page_title = title or f"CoderMind {command} Explain View"
@@ -312,6 +310,8 @@ def _render_page(
     evidence: Mapping[str, Any],
 ) -> str:
     status_html = f"<span class=\"status\">{_h(status)}</span>" if status else ""
+    code_delta_anchors = _code_delta_anchors(code_deltas)
+    code_file_anchors = _code_file_anchor_map(code_deltas, code_delta_anchors)
     return f"""<!doctype html>
 <html lang=\"en\">
 <head>
@@ -367,9 +367,8 @@ def _render_page(
 {_render_summary_cards(summary_cards)}
 {_render_timeline(stages)}
 {_render_safety_boundary(user_decisions)}
-{_render_why_these_nodes(retrievals, rpg_nodes, dep_nodes)}
-{_render_focused_impact(focused_view)}
-{_render_code_deltas(code_deltas)}
+{_render_semantic_code_impact_chain(retrievals, rpg_nodes, dep_nodes, focused_view, code_file_anchors)}
+{_render_code_deltas(code_deltas, code_delta_anchors)}
 {_render_verification(verification)}
 {_render_artifacts(artifacts)}
 {_render_evidence(evidence)}
@@ -502,11 +501,46 @@ def _render_retrievals(retrievals: list[dict[str, Any]], *, title: str = "Retrie
     return f"<section><h2>{_h(title)}</h2>{body}</section>"
 
 
-def _render_code_deltas(deltas: list[dict[str, Any]]) -> str:
+def _delta_file(delta: Mapping[str, Any]) -> str:
+    return str(delta.get("file") or delta.get("path") or "")
+
+
+def _code_delta_anchors(deltas: list[dict[str, Any]]) -> list[str]:
+    anchors: list[str] = []
+    used: dict[str, int] = {}
+    for index, delta in enumerate(deltas, start=1):
+        file_path = _delta_file(delta) or f"change-{index}"
+        base = _slug(f"diff-{file_path}")
+        count = used.get(base, 0) + 1
+        used[base] = count
+        anchors.append(base if count == 1 else f"{base}-{count}")
+    return anchors
+
+
+def _code_file_anchor_map(deltas: list[dict[str, Any]], anchors: list[str]) -> dict[str, str]:
+    file_anchors: dict[str, str] = {}
+    for delta, anchor in zip(deltas, anchors):
+        file_path = _delta_file(delta)
+        if file_path and file_path not in file_anchors:
+            file_anchors[file_path] = anchor
+    return file_anchors
+
+
+def _diff_file_link(file_path: Any, file_anchors: Mapping[str, str]) -> str:
+    file_text = str(file_path or "")
+    anchor = file_anchors.get(file_text)
+    if not anchor:
+        return f"<code>{_h(file_text)}</code>"
+    return f"<a href=\"#{_h_attr(anchor)}\"><code>{_h(file_text)}</code></a>"
+
+
+def _render_code_deltas(deltas: list[dict[str, Any]], anchors: list[str] | None = None) -> str:
     if not deltas:
         return ""
+    anchors = anchors or _code_delta_anchors(deltas)
     blocks = []
-    for delta in deltas:
+    for index, delta in enumerate(deltas):
+        anchor = anchors[index] if index < len(anchors) else _slug(f"diff-{index + 1}")
         diff = delta.get("diff", "")
         diff_html = "<p class=\"empty\">No diff recorded.</p>"
         if diff:
@@ -519,7 +553,7 @@ def _render_code_deltas(deltas: list[dict[str, Any]]) -> str:
                 "</details>"
             )
         blocks.append(
-            "<div class=\"delta\">"
+            f"<div class=\"delta\" id=\"{_h_attr(anchor)}\">"
             "<div class=\"delta-head\">"
             f"<code>{_h(delta.get('file', ''))}</code>"
             f"<span class=\"badge\">{_h(delta.get('change_type', ''))}</span>"
@@ -530,21 +564,317 @@ def _render_code_deltas(deltas: list[dict[str, Any]]) -> str:
     return f"<section><h2>What changed?</h2>{''.join(blocks)}</section>"
 
 
-def _render_why_these_nodes(
+def _summary_badges(summary: Mapping[str, Any], labels: list[tuple[str, str, Any]]) -> str:
+    badges = []
+    for label, key, fallback in labels:
+        value = summary.get(key, fallback)
+        badges.append(f"<span class=\"badge\">{_h(label)}: <strong>{_h(value)}</strong></span>")
+    return "<div class=\"focus-summary\">" + "".join(badges) + "</div>"
+
+
+def _mapping_changed_files(mapping: Mapping[str, Any], rpg_node: Mapping[str, Any]) -> list[str]:
+    return _ordered_texts(_as_sequence(mapping.get("changed_files")) + _as_sequence(rpg_node.get("changed_files")))
+
+
+def _ordered_texts(values: Sequence[Any]) -> list[str]:
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for value in values:
+        if value in (None, ""):
+            continue
+        text = str(value)
+        if text in seen:
+            continue
+        seen.add(text)
+        ordered.append(text)
+    return ordered
+
+
+def _changed_file_links(files: Sequence[Any], file_anchors: Mapping[str, str]) -> str:
+    file_list = _ordered_texts(list(files))
+    if not file_list:
+        return "<span class=\"empty\">No changed files mapped.</span>"
+    return ", ".join(_diff_file_link(file_path, file_anchors) for file_path in file_list)
+
+
+def _chain_warning_html(warnings: Sequence[Mapping[str, Any]]) -> str:
+    if not warnings:
+        return "<span class=\"empty\">No warnings.</span>"
+    items = []
+    for warning in warnings:
+        warning_type = warning.get("type", "warning")
+        context = {key: value for key, value in warning.items() if key not in {"type", "message"}}
+        context_html = f" <code>{_h(context)}</code>" if context else ""
+        items.append(f"<li><code>{_h(warning_type)}</code> {_h(warning.get('message', ''))}{context_html}</li>")
+    return '<ul class="hit-list">' + "".join(items) + "</ul>"
+
+
+def _chain_edge_html(edges: Sequence[Mapping[str, Any]]) -> str:
+    if not edges:
+        return "<span class=\"empty\">No visible neighborhood edges.</span>"
+    items = []
+    for edge in edges:
+        source = edge.get("source_node_id", "")
+        target = edge.get("target_node_id", "")
+        relation = edge.get("relation") or "dependency"
+        direction = edge.get("direction", "")
+        path = edge.get("path", "")
+        reason = edge.get("reason", "")
+        items.append(
+            "<li>"
+            f"<code>{_h(source)}</code> → <code>{_h(target)}</code>"
+            f" <span class=\"badge\">{_h(relation)}</span>"
+            f" {_h(direction)}"
+            f"<div class=\"reason\">{_h(path)} {_h(reason)}</div>"
+            "</li>"
+        )
+    return '<ul class="hit-list">' + "".join(items) + "</ul>"
+
+
+def _combined_hidden_counts(hidden_counts: Mapping[str, Any]) -> list[tuple[str, int]]:
+    relation_keys = {"caller": "callers", "callee": "callees", "import": "imports", "inheritance": "inheritance"}
+    hidden_relations = hidden_counts.get("relations") if isinstance(hidden_counts.get("relations"), Mapping) else {}
+    rows: list[tuple[str, int]] = []
+    for relation, count_key in relation_keys.items():
+        count = hidden_counts.get(count_key) or 0
+        if isinstance(hidden_relations, Mapping):
+            count += hidden_relations.get(relation, 0) or 0
+        try:
+            count_int = int(count)
+        except (TypeError, ValueError):
+            count_int = 0
+        if count_int:
+            rows.append((relation, count_int))
+    return rows
+
+
+def _hidden_context_html(hidden_counts: Mapping[str, Any]) -> str:
+    parts = []
+    for relation, count in _combined_hidden_counts(hidden_counts):
+        parts.append(f"<p class=\"reason\">Hidden {_h(count)} additional {_h(relation)} neighbors.</p>")
+    cap_rows = []
+    for key in ("primary_rpg_nodes", "primary_code_nodes", "edges"):
+        value = hidden_counts.get(key)
+        if value:
+            cap_rows.append(f"<tr><th>{_h(key)}</th><td>{_h(value)}</td></tr>")
+    if cap_rows:
+        parts.append("<table><tbody>" + "".join(cap_rows) + "</tbody></table>")
+    return "".join(parts)
+
+
+def _focused_inspector_payload(focused_view: Mapping[str, Any]) -> dict[str, Any]:
+    payload: dict[str, Any] = {}
+    for key, value in focused_view.items():
+        if key in {"unmatched_code_deltas"}:
+            unmatched_files = [
+                _delta_file(delta)
+                for delta in _as_sequence(value)
+                if isinstance(delta, Mapping) and _delta_file(delta)
+            ]
+            if unmatched_files:
+                payload["unmatched_changed_files"] = unmatched_files
+            continue
+        payload[key] = value
+    return payload
+
+
+def _render_feature_chain_rows(focused_view: dict[str, Any], file_anchors: Mapping[str, str]) -> str:
+    rpg_nodes = [node for node in _as_sequence(focused_view.get("primary_rpg_nodes")) if isinstance(node, Mapping)]
+    code_nodes = [node for node in _as_sequence(focused_view.get("primary_code_nodes")) if isinstance(node, Mapping)]
+    mappings = [mapping for mapping in _as_sequence(focused_view.get("mappings")) if isinstance(mapping, Mapping)]
+    edges = [edge for edge in _as_sequence(focused_view.get("edges")) if isinstance(edge, Mapping)]
+    warnings = [warning for warning in _as_sequence(focused_view.get("warnings")) if isinstance(warning, Mapping)]
+    if not rpg_nodes and not mappings and not code_nodes:
+        return "<p class=\"empty\">No semantic-code impact chain rows recorded.</p>"
+
+    rpg_by_id = {str(node.get("node_id")): node for node in rpg_nodes if node.get("node_id") not in (None, "")}
+    code_by_id = {
+        str(node.get("node_id") or node.get("dep_node_id")): node
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+    mappings_by_rpg: dict[str, list[Mapping[str, Any]]] = {}
+    mapped_code_ids_by_rpg: dict[str, set[str]] = {}
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id") or ""
+        rpg_text = str(rpg_id)
+        mappings_by_rpg.setdefault(rpg_text, []).append(mapping)
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        if code_id not in (None, ""):
+            mapped_code_ids_by_rpg.setdefault(rpg_text, set()).add(str(code_id))
+        if rpg_text and rpg_text not in rpg_by_id:
+            rpg_by_id[rpg_text] = {"node_id": rpg_text, "mapping_status": mapping.get("status", "")}
+    edge_rows_by_rpg: dict[str, list[Mapping[str, Any]]] = {str(node_id): [] for node_id in rpg_by_id}
+    for edge in edges:
+        rpg_id = edge.get("rpg_node_id")
+        matched = False
+        if rpg_id not in (None, "") and str(rpg_id) in edge_rows_by_rpg:
+            edge_rows_by_rpg[str(rpg_id)].append(edge)
+            matched = True
+        source = str(edge.get("source_node_id") or "")
+        target = str(edge.get("target_node_id") or "")
+        for node_id, code_ids in mapped_code_ids_by_rpg.items():
+            if source in code_ids or target in code_ids:
+                edge_rows_by_rpg.setdefault(node_id, []).append(edge)
+                matched = True
+        if not matched and len(edge_rows_by_rpg) == 1:
+            only_id = next(iter(edge_rows_by_rpg))
+            edge_rows_by_rpg[only_id].append(edge)
+
+    warnings_by_rpg: dict[str, list[Mapping[str, Any]]] = {str(node_id): [] for node_id in rpg_by_id}
+    global_warnings = []
+    for warning in warnings:
+        node_id = warning.get("node_id") or warning.get("rpg_node_id")
+        if node_id not in (None, "") and str(node_id) in warnings_by_rpg:
+            warnings_by_rpg[str(node_id)].append(warning)
+        else:
+            global_warnings.append(warning)
+
+    rows = []
+    for node_id, rpg_node in rpg_by_id.items():
+        node_mappings = mappings_by_rpg.get(node_id) or []
+        mapping_items = []
+        changed_files: list[Any] = list(_as_sequence(rpg_node.get("changed_files")))
+        for mapping in node_mappings:
+            code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+            code_node = code_by_id.get(str(code_id)) if code_id not in (None, "") else None
+            changed_files.extend(_mapping_changed_files(mapping, rpg_node))
+            status = mapping.get("status") or rpg_node.get("mapping_status") or "recorded"
+            source = mapping.get("source", "")
+            reason = mapping.get("reason") or rpg_node.get("reason") or ""
+            path = mapping.get("path") or (code_node or {}).get("path") or ""
+            mapping_items.append(
+                "<li>"
+                f"<span class=\"badge\">{_h(status)}</span> {_focused_node_cell(code_id, code_node)}"
+                f"<div class=\"reason\">{_h(source)} {_h(path)} {_h(reason)}</div>"
+                "</li>"
+            )
+        if not mapping_items:
+            mapping_items.append(f"<li><span class=\"badge\">{_h(rpg_node.get('mapping_status') or rpg_node.get('status') or 'recorded')}</span> <span class=\"empty\">No mapped code node.</span></li>")
+        mapping_html = '<ul class="hit-list">' + "".join(mapping_items) + "</ul>"
+        node_hidden = rpg_node.get("hidden_counts") if isinstance(rpg_node.get("hidden_counts"), Mapping) else {}
+        hidden_html = _hidden_context_html(node_hidden)
+        rows.append(
+            "<tr>"
+            f"<td>{_focused_node_cell(node_id, rpg_node)}<div class=\"reason\">{_h(rpg_node.get('reason', ''))}</div></td>"
+            f"<td>{mapping_html}</td>"
+            f"<td>{_changed_file_links(changed_files or _as_sequence(rpg_node.get('affected_files')), file_anchors)}</td>"
+            f"<td>{_chain_edge_html(edge_rows_by_rpg.get(node_id, []))}{hidden_html}</td>"
+            f"<td>{_chain_warning_html(warnings_by_rpg.get(node_id, []))}</td>"
+            "</tr>"
+        )
+
+    orphan_code_nodes = [
+        node for code_id, node in code_by_id.items()
+        if not any(code_id in ids for ids in mapped_code_ids_by_rpg.values())
+    ]
+    if orphan_code_nodes:
+        orphan_items = "".join(
+            f"<li>{_focused_node_cell(node.get('node_id') or node.get('dep_node_id'), node)} <span class=\"badge\">{_h(node.get('source', ''))}</span></li>"
+            for node in orphan_code_nodes
+        )
+        rows.append(
+            "<tr>"
+            "<td><span class=\"empty\">Changed code without selected feature</span></td>"
+            f"<td><ul class=\"hit-list\">{orphan_items}</ul></td>"
+            "<td><span class=\"empty\">No changed files mapped.</span></td>"
+            "<td><span class=\"empty\">No visible neighborhood edges.</span></td>"
+            "<td><span class=\"empty\">No warnings.</span></td>"
+            "</tr>"
+        )
+
+    table = (
+        "<table><thead><tr><th>Feature group</th><th>Semantic → code evidence</th>"
+        "<th>Changed files</th><th>Neighborhood</th><th>Warnings</th></tr></thead><tbody>"
+        + "".join(rows)
+        + "</tbody></table>"
+    )
+    if global_warnings:
+        table += f"<h3>Global warnings</h3>{_chain_warning_html(global_warnings)}"
+    return table
+
+
+def _render_legacy_chain_rows(
     retrievals: list[dict[str, Any]],
     rpg_nodes: list[dict[str, Any]],
     dep_nodes: list[dict[str, Any]],
 ) -> str:
-    if not retrievals and not rpg_nodes and not dep_nodes:
-        return ""
     blocks = []
     if retrievals:
-        blocks.append(_render_retrievals(retrievals, title="Retrieval evidence", as_section=False))
-    if rpg_nodes:
-        blocks.append(_render_node_rows("Selected feature groups", rpg_nodes, dep_graph=False))
-    if dep_nodes:
-        blocks.append(_render_node_rows("Mapped code relations", dep_nodes, dep_graph=True))
-    return f"<section><h2>Why these nodes?</h2>{''.join(blocks)}</section>"
+        blocks.append(_render_retrievals(retrievals, title="Retrieval audit trail", as_section=False))
+    if rpg_nodes or dep_nodes:
+        rows = []
+        dep_by_feature: dict[str, list[dict[str, Any]]] = {}
+        for dep_node in dep_nodes:
+            source_feature = str(dep_node.get("source_feature") or "")
+            dep_by_feature.setdefault(source_feature, []).append(dep_node)
+        for node in rpg_nodes or [{"node_id": ""}]:
+            node_id = str(node.get("node_id") or "")
+            mapped = dep_by_feature.get(node_id) or ([] if node_id else dep_nodes)
+            mapping_html = "<span class=\"empty\">No mapped code nodes recorded.</span>"
+            if mapped:
+                items = []
+                for dep_node in mapped:
+                    dep_id = dep_node.get("dep_node_id") or dep_node.get("node_id")
+                    items.append(
+                        "<li>"
+                        f"<code>{_h(dep_id)}</code> {_h(dep_node.get('path', ''))}"
+                        f" <span class=\"badge\">{_h(dep_node.get('relation') or dep_node.get('change') or dep_node.get('status', ''))}</span>"
+                        "</li>"
+                    )
+                mapping_html = '<ul class="hit-list">' + "".join(items) + "</ul>"
+            rows.append(
+                "<tr>"
+                f"<td>{_focused_node_cell(node_id, node)}</td>"
+                f"<td>{mapping_html}</td>"
+                "<td><span class=\"empty\">No changed files mapped.</span></td>"
+                "<td><span class=\"empty\">No visible neighborhood edges.</span></td>"
+                "<td><span class=\"empty\">No warnings.</span></td>"
+                "</tr>"
+            )
+        blocks.append(
+            "<table><thead><tr><th>Feature group</th><th>Semantic → code evidence</th>"
+            "<th>Changed files</th><th>Neighborhood</th><th>Warnings</th></tr></thead><tbody>"
+            + "".join(rows)
+            + "</tbody></table>"
+        )
+    return "".join(blocks)
+
+
+def _render_semantic_code_impact_chain(
+    retrievals: list[dict[str, Any]],
+    rpg_nodes: list[dict[str, Any]],
+    dep_nodes: list[dict[str, Any]],
+    focused_view: dict[str, Any],
+    file_anchors: Mapping[str, str],
+) -> str:
+    if not focused_view and not retrievals and not rpg_nodes and not dep_nodes:
+        return ""
+    if focused_view:
+        summary = focused_view.get("summary") if isinstance(focused_view.get("summary"), Mapping) else {}
+        summary_html = _summary_badges(summary, [
+            ("Selected feature groups", "selected_feature_groups", len(_as_sequence(focused_view.get("primary_rpg_nodes")))),
+            ("Primary code nodes", "primary_code_nodes", len(_as_sequence(focused_view.get("primary_code_nodes")))),
+            ("Mapped relations", "mapped_code_relations", len(_as_sequence(focused_view.get("mappings")))),
+            ("Missing mappings", "missing_mappings", 0),
+            ("Edges shown", "edges", len(_as_sequence(focused_view.get("edges")))),
+            ("Warnings", "warnings", len(_as_sequence(focused_view.get("warnings")))),
+        ])
+        hidden_counts = focused_view.get("hidden_counts") if isinstance(focused_view.get("hidden_counts"), Mapping) else {}
+        hidden_html = _hidden_context_html(hidden_counts)
+        inspector_html = _focused_graph_metadata(focused_view)
+        body = f"{summary_html}{_render_feature_chain_rows(focused_view, file_anchors)}{hidden_html}{inspector_html}"
+    else:
+        body = _render_legacy_chain_rows(retrievals, rpg_nodes, dep_nodes)
+    return f"<section><h2>semantic-code impact chain</h2>{body}</section>"
+
+
+def _render_why_these_nodes(
+    retrievals: list[dict[str, Any]],
+    rpg_nodes: list[dict[str, Any]],
+    dep_nodes: list[dict[str, Any]],
+) -> str:
+    return _render_semantic_code_impact_chain(retrievals, rpg_nodes, dep_nodes, {}, {})
 
 
 def _render_node_rows(title: str, nodes: list[dict[str, Any]], *, dep_graph: bool) -> str:
@@ -579,7 +909,7 @@ def _render_node_rows(title: str, nodes: list[dict[str, Any]], *, dep_graph: boo
 
 
 def _focused_graph_metadata(focused_view: dict[str, Any]) -> str:
-    data = json.dumps(focused_view, indent=2, ensure_ascii=False, default=_json_default)
+    data = json.dumps(_focused_inspector_payload(focused_view), indent=2, ensure_ascii=False, default=_json_default)
     return f"<details><summary>Inspector JSON</summary><pre>{_h(data)}</pre></details>"
 
 
@@ -598,119 +928,7 @@ def _focused_node_cell(node_id: Any, node: Mapping[str, Any] | None) -> str:
 
 
 def _render_focused_impact(focused_view: dict[str, Any]) -> str:
-    if not focused_view:
-        return ""
-    summary = focused_view.get("summary") if isinstance(focused_view.get("summary"), Mapping) else {}
-    rpg_nodes = [node for node in _as_sequence(focused_view.get("primary_rpg_nodes")) if isinstance(node, Mapping)]
-    code_nodes = [node for node in _as_sequence(focused_view.get("primary_code_nodes")) if isinstance(node, Mapping)]
-    mappings = [mapping for mapping in _as_sequence(focused_view.get("mappings")) if isinstance(mapping, Mapping)]
-    edges = [edge for edge in _as_sequence(focused_view.get("edges")) if isinstance(edge, Mapping)]
-    hidden_counts = focused_view.get("hidden_counts") if isinstance(focused_view.get("hidden_counts"), Mapping) else {}
-    warnings = [warning for warning in _as_sequence(focused_view.get("warnings")) if isinstance(warning, Mapping)]
-    rpg_by_id = {str(node.get("node_id")): node for node in rpg_nodes if node.get("node_id") not in (None, "")}
-    code_by_id = {
-        str(node.get("node_id") or node.get("dep_node_id")): node
-        for node in code_nodes
-        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
-    }
-    summary_items = [
-        ("Primary RPG nodes", summary.get("primary_rpg_nodes", len(rpg_nodes))),
-        ("Primary code nodes", summary.get("primary_code_nodes", len(code_nodes))),
-        ("Mapped relations", summary.get("mapped_code_relations", len([row for row in mappings if row.get("code_node_id")]))),
-        ("Missing mappings", summary.get("missing_mappings", len([row for row in mappings if row.get("status") == "missing"]))),
-        ("Edges shown", summary.get("edges", len(edges))),
-        ("Warnings", summary.get("warnings", len(warnings))),
-    ]
-    summary_html = "<div class=\"focus-summary\">" + "".join(
-        f"<span class=\"badge\">{_h(label)}: <strong>{_h(value)}</strong></span>"
-        for label, value in summary_items
-    ) + "</div>"
-
-    code_rows = []
-    for node in code_nodes:
-        node_id = node.get("node_id") or node.get("dep_node_id")
-        code_rows.append(
-            "<tr>"
-            f"<td>{_focused_node_cell(node_id, node)}</td>"
-            f"<td>{_h(node.get('type') or node.get('kind') or '')}</td>"
-            f"<td>{_h(node.get('status', ''))}</td>"
-            f"<td>{_h(node.get('source', ''))}</td>"
-            "</tr>"
-        )
-    code_html = "<p class=\"empty\">No primary code nodes recorded.</p>"
-    if code_rows:
-        code_html = "<table><thead><tr><th>Code node</th><th>Type</th><th>Status</th><th>Source</th></tr></thead><tbody>" + "".join(code_rows) + "</tbody></table>"
-
-    mapping_rows = []
-    for mapping in mappings:
-        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
-        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
-        rpg_node = rpg_by_id.get(str(rpg_id)) if rpg_id not in (None, "") else None
-        code_node = code_by_id.get(str(code_id)) if code_id not in (None, "") else None
-        changed_files = ", ".join(str(item) for item in _as_sequence(mapping.get("changed_files")))
-        mapping_rows.append(
-            "<tr>"
-            f"<td>{_focused_node_cell(rpg_id, rpg_node)}</td>"
-            f"<td>{_focused_node_cell(code_id, code_node)}</td>"
-            f"<td>{_h(mapping.get('status', ''))}</td>"
-            f"<td>{_h(mapping.get('path') or (code_node or {}).get('path') or '')}</td>"
-            f"<td>{_h(mapping.get('source', ''))}</td>"
-            f"<td>{_h(mapping.get('reason', ''))}</td>"
-            f"<td>{_h(changed_files)}</td>"
-            "</tr>"
-        )
-    mappings_html = "<p class=\"empty\">No semantic-code mappings recorded.</p>"
-    if mapping_rows:
-        mappings_html = (
-            "<table><thead><tr><th>Semantic node</th><th>Code node</th><th>Status</th>"
-            "<th>Path</th><th>Source</th><th>Reason</th><th>Changed files</th></tr></thead><tbody>"
-            + "".join(mapping_rows)
-            + "</tbody></table>"
-        )
-
-    hidden_relations = hidden_counts.get("relations") if isinstance(hidden_counts.get("relations"), Mapping) else {}
-    relation_hidden_keys = {"caller": "callers", "callee": "callees", "import": "imports", "inheritance": "inheritance"}
-    edges_by_relation: dict[str, list[Mapping[str, Any]]] = {}
-    for edge in edges:
-        relation = str(edge.get("relation") or "dependency")
-        edges_by_relation.setdefault(relation, []).append(edge)
-    relation_names = set(edges_by_relation)
-    for relation, hidden_key in relation_hidden_keys.items():
-        if hidden_counts.get(hidden_key):
-            relation_names.add(relation)
-    relation_blocks = []
-    for relation in sorted(relation_names):
-        hidden = hidden_relations.get(relation, 0) if isinstance(hidden_relations, Mapping) else 0
-        hidden += hidden_counts.get(relation_hidden_keys.get(relation, ""), 0) or 0
-        relation_blocks.append(_render_focused_impact_group({"relation": relation, "edges": edges_by_relation.get(relation, []), "hidden": hidden}))
-    neighborhood_html = "".join(relation_blocks) or "<p class=\"empty\">No one-hop neighborhood edges recorded.</p>"
-
-    warning_html = "<p class=\"empty\">No focused warnings recorded.</p>"
-    if warnings:
-        warning_items = []
-        for warning in warnings:
-            warning_type = warning.get("type", "warning")
-            context = {key: value for key, value in warning.items() if key not in {"type", "message"}}
-            context_html = f" <code>{_h(context)}</code>" if context else ""
-            warning_items.append(f"<li><code>{_h(warning_type)}</code> {_h(warning.get('message', ''))}{context_html}</li>")
-        warning_html = '<ul class="warning-list">' + "".join(warning_items) + "</ul>"
-
-    hidden_html = "<p class=\"empty\">No hidden focused context recorded.</p>"
-    if hidden_counts:
-        hidden_rows = "".join(f"<tr><th>{_h(key)}</th><td>{_h(value)}</td></tr>" for key, value in hidden_counts.items())
-        hidden_html = "<table><tbody>" + hidden_rows + "</tbody></table>"
-
-    return (
-        "<section><h2>Focused impact view</h2>"
-        f"{summary_html}"
-        f"<h3>Primary code nodes</h3>{code_html}"
-        f"<h3>Semantic-code mappings</h3>{mappings_html}"
-        f"<h3>Capped neighborhood</h3>{neighborhood_html}"
-        f"<h3>Warnings</h3>{warning_html}"
-        f"<h3>Hidden context</h3>{hidden_html}"
-        f"{_focused_graph_metadata(focused_view)}"
-        "</section>"
-    )
+    return _render_semantic_code_impact_chain([], [], [], focused_view, {})
 
 
 def _render_focused_impact_group(group: Mapping[str, Any]) -> str:
@@ -755,8 +973,100 @@ def _render_artifacts(artifacts: list[dict[str, Any]]) -> str:
     return f"<section><h2>Artifact links</h2>{body}</section>"
 
 
+def _compact_artifact_pointers(value: Any) -> list[dict[str, Any]]:
+    pointers = []
+    for item in _as_sequence(value):
+        if not isinstance(item, Mapping):
+            continue
+        row: dict[str, Any] = {}
+        for key in ("label", "path", "status"):
+            if item.get(key) not in (None, ""):
+                row[key] = item.get(key)
+        if row:
+            pointers.append(row)
+    return pointers
+
+
+def _compact_change_summary(value: Any) -> list[dict[str, Any]]:
+    rows = []
+    for item in _as_sequence(value):
+        if not isinstance(item, Mapping):
+            continue
+        diff = item.get("diff") or ""
+        row: dict[str, Any] = {"file": item.get("file") or item.get("path") or ""}
+        if item.get("change_type") not in (None, ""):
+            row["change_type"] = item.get("change_type")
+        row["has_diff"] = bool(diff)
+        if diff:
+            row["diff_lines"] = len(str(diff).splitlines())
+        rows.append(row)
+    return rows
+
+
+def _compact_payload(value: Any, *, depth: int = 0) -> Any:
+    if depth > 4:
+        return "..."
+    if isinstance(value, Mapping):
+        compacted: dict[str, Any] = {}
+        for key, item in value.items():
+            key_text = str(key)
+            if key_text in {"code_deltas", "focused_view", "focused_impact", "focused_graph", "evidence"}:
+                continue
+            if key_text == "diff":
+                compacted["has_diff"] = bool(item)
+                if item:
+                    compacted["diff_lines"] = len(str(item).splitlines())
+                continue
+            if key_text == "artifacts":
+                artifact_pointers = _compact_artifact_pointers(item)
+                if artifact_pointers:
+                    compacted["artifact_paths"] = artifact_pointers
+                continue
+            compact_item = _compact_payload(item, depth=depth + 1)
+            if compact_item in (None, "", [], {}):
+                continue
+            compacted[key_text] = compact_item
+        return compacted
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        rows = []
+        for item in value:
+            compact_item = _compact_payload(item, depth=depth + 1)
+            if compact_item not in (None, "", [], {}):
+                rows.append(compact_item)
+        return rows
+    return value
+
+
+def _compact_evidence(evidence: Mapping[str, Any]) -> dict[str, Any]:
+    compacted: dict[str, Any] = {}
+    artifacts = _compact_artifact_pointers(evidence.get("artifacts"))
+    if artifacts:
+        compacted["artifact_paths"] = artifacts
+    for key in ("command", "title", "status", "timestamp", "summary", "steps", "retrievals", "rpg_deltas", "dep_graph_deltas", "verification", "user_decisions"):
+        value = evidence.get(key)
+        if value in (None, "", [], {}):
+            continue
+        compacted[key] = _compact_payload(value)
+    change_summary = _compact_change_summary(evidence.get("code_deltas"))
+    if change_summary:
+        compacted["changed_files"] = change_summary
+    nested = evidence.get("evidence")
+    if isinstance(nested, Mapping):
+        nested_artifacts = _compact_artifact_pointers(nested.get("artifact_paths") or nested.get("artifacts"))
+        if nested_artifacts and not artifacts:
+            compacted["artifact_paths"] = nested_artifacts
+        audit_source = nested.get("audit_summary") if isinstance(nested.get("audit_summary"), Mapping) else {
+            key: value for key, value in nested.items()
+            if key not in {"artifact_paths", "artifacts"}
+        }
+        audit = _compact_payload(audit_source)
+        if audit:
+            compacted["audit_summary"] = audit
+    return compacted
+
+
 def _render_evidence(evidence: Mapping[str, Any]) -> str:
-    data = json.dumps(evidence, indent=2, ensure_ascii=False, default=_json_default)
+    data = json.dumps(_compact_evidence(evidence), indent=2, ensure_ascii=False, default=_json_default)
     return f"<section><details><summary>Evidence JSON</summary><pre>{_h(data)}</pre></details></section>"
 
 
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 6368a3d..364ed3d 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -934,6 +934,133 @@ def _rollback_path(apply_result: Dict[str, Any]) -> Any:
     return backups.get("rpg") or backups.get("dep_graph") or apply_result.get("rollback_command")
 
 
+def _artifact_path_pointers(artifact_rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    pointers: List[Dict[str, Any]] = []
+    for row in artifact_rows:
+        pointer: Dict[str, Any] = {}
+        for key in ("label", "path", "status"):
+            if row.get(key) not in (None, ""):
+                pointer[key] = row.get(key)
+        if pointer:
+            pointers.append(pointer)
+    return pointers
+
+
+def _compact_plan_audit(plan: Dict[str, Any]) -> Dict[str, Any]:
+    changes = []
+    for change in plan.get("code_changes") or []:
+        if not isinstance(change, dict):
+            continue
+        row: Dict[str, Any] = {}
+        for key in ("file_path", "change_type", "action"):
+            if change.get(key) not in (None, ""):
+                row[key] = change.get(key)
+        if row:
+            changes.append(row)
+    return {
+        "affected_nodes": [str(node_id) for node_id in _listify(plan.get("affected_nodes"))],
+        "code_changes": changes,
+    }
+
+
+def _compact_impact_audit(impact: Dict[str, Any]) -> Dict[str, Any]:
+    results = impact.get("results") if isinstance(impact.get("results"), dict) else {}
+    affected_files: List[Any] = []
+    mapped_relations = 0
+    node_summaries = []
+    for node_id, row in results.items():
+        row = row if isinstance(row, dict) else {}
+        dep_nodes = _listify(row.get("dep_nodes"))
+        files = _listify(row.get("affected_files"))
+        affected_files.extend(files)
+        mapped_relations += len(dep_nodes)
+        summary = row.get("impact_summary") if isinstance(row.get("impact_summary"), dict) else {}
+        node_summaries.append({
+            "node_id": node_id,
+            "mapped_code_relations": len(dep_nodes),
+            "affected_files": len(files),
+            "total_callers": summary.get("total_callers", len(row.get("callers") or [])),
+            "total_callees": summary.get("total_callees", len(row.get("callees") or [])),
+        })
+    return {
+        "type": impact.get("type"),
+        "result_count": len(results),
+        "affected_files": _ordered_unique(affected_files),
+        "mapped_code_relations": mapped_relations,
+        "results": node_summaries,
+    }
+
+
+def _compact_code_audit(code_result: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "success": code_result.get("success"),
+        "last_status": code_result.get("last_status"),
+        "commit_sha": code_result.get("commit_sha"),
+        "files_modified": [str(path) for path in _listify(code_result.get("files_modified"))],
+        "iterations": len(code_result.get("iterations") or []),
+    }
+
+
+def _compact_apply_audit(apply_result: Dict[str, Any]) -> Dict[str, Any]:
+    applied = []
+    for feature in apply_result.get("applied_features") or []:
+        if not isinstance(feature, dict):
+            continue
+        row: Dict[str, Any] = {}
+        for key in ("node_id", "action", "change"):
+            if feature.get(key) not in (None, ""):
+                row[key] = feature.get(key)
+        if row:
+            applied.append(row)
+    test_result = apply_result.get("test_result") if isinstance(apply_result.get("test_result"), dict) else {}
+    return {
+        "status": _apply_status(apply_result),
+        "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
+        "applied_features": applied,
+        "rollback_path": _rollback_path(apply_result),
+        "test_status": _status_from_bool(test_result.get("passed")),
+    }
+
+
+def _compact_review_audit(result: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "status": result.get("type", "review"),
+        "success": result.get("success", result.get("type") == "skipped"),
+        "iterations": len(result.get("iterations") or []),
+        "suggestions": len(result.get("suggestions") or []),
+        "reason": result.get("reason"),
+    }
+
+
+def _compact_review_evidence(
+    artifacts: Dict[str, Any],
+    artifact_rows: List[Dict[str, Any]],
+    result: Dict[str, Any],
+) -> Dict[str, Any]:
+    validate = artifacts.get("validate") if isinstance(artifacts.get("validate"), dict) else {}
+    locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
+    plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
+    impact = artifacts.get("impact") if isinstance(artifacts.get("impact"), dict) else {}
+    code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
+    apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
+    return {
+        "artifact_paths": _artifact_path_pointers(artifact_rows),
+        "audit_summary": {
+            "validate": {"type": validate.get("type"), "message": validate.get("message")},
+            "locate": {
+                "type": locate.get("type"),
+                "query": locate.get("query"),
+                "candidate_count": len(locate.get("results") or []),
+            },
+            "plan": _compact_plan_audit(plan),
+            "impact": _compact_impact_audit(impact),
+            "code": _compact_code_audit(code_result),
+            "apply": _compact_apply_audit(apply_result),
+            "review": _compact_review_audit(result),
+        },
+    }
+
+
 def _user_decision(result: Dict[str, Any], artifacts: Dict[str, Any]) -> UserDecisionEvent:
     apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
@@ -973,7 +1100,7 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
     code_deltas = _code_delta_rows(artifacts)
     focused_view = _feature_evidence_groups(artifacts, candidates, code_deltas, result)
     artifact_rows = _artifact_links(plan_path, impact_path)
-    evidence = {"artifacts": artifacts, "review_result": result, "focused_view": focused_view}
+    evidence = _compact_review_evidence(artifacts, artifact_rows, result)
     try:
         report_run = CommandRun(
             command="rpg_edit",
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index a5f0008..9022b72 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -218,6 +218,37 @@ def fake_write_command_report(run):
         assert "impact callers=1, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
         assert data["code_deltas"] == [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
+        artifact_paths = {item["label"]: item["path"] for item in data["artifacts"]}
+        assert artifact_paths["validate"] == str(validate_path)
+        assert artifact_paths["locate"] == str(locate_path)
+        assert artifact_paths["plan"] == str(plan_path)
+        assert artifact_paths["impact"] == str(impact_path)
+        assert artifact_paths["code_result"] == str(code_path)
+        assert artifact_paths["apply_result"] == str(apply_path)
+        assert artifact_paths["review_result"] == str(review_path)
+        evidence = data["evidence"]
+        evidence_text = json.dumps(evidence, ensure_ascii=False)
+        assert "artifacts" not in evidence
+        assert "review_result" not in evidence
+        assert "focused_view" not in evidence
+        assert "focused_graph" not in evidence
+        assert "focused_impact" not in evidence
+        assert "+new <unsafe>" not in evidence_text
+        evidence_paths = {item["label"]: item["path"] for item in evidence["artifact_paths"]}
+        assert evidence_paths == artifact_paths
+        audit = evidence["audit_summary"]
+        assert audit["review"]["status"] == "skipped"
+        assert audit["review"]["success"] is True
+        assert audit["plan"]["affected_nodes"] == ["n1", "n2"]
+        assert audit["plan"]["code_changes"] == [{"file_path": "a.py"}]
+        assert audit["impact"]["result_count"] == 2
+        assert audit["impact"]["mapped_code_relations"] == 1
+        assert audit["code"]["commit_sha"] == "abc123"
+        assert audit["code"]["files_modified"] == ["a.py"]
+        assert audit["apply"]["status"] == "success"
+        assert audit["apply"]["dep_graph_refreshed"] is True
+        assert audit["apply"]["rollback_path"] == str(backup_path)
+        assert audit["apply"]["test_status"] == "passed"
         assert "focused_graph" not in data
         assert "focused_impact" not in data
         assert not any(item["label"] == "focused_graph" for item in data["artifacts"])
@@ -336,6 +367,34 @@ def fake_write_command_report(run):
         assert "1 mapped code relations" in data["retrievals"][0]["hits"][0]["reason"]
         assert "impact callers=0, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
+        artifact_paths = {item["label"]: item["path"] for item in data["artifacts"]}
+        assert artifact_paths["validate"] == str(validate_path)
+        assert artifact_paths["locate"] == str(locate_path)
+        assert artifact_paths["plan"] == str(plan_path)
+        assert artifact_paths["impact"] == str(impact_path)
+        assert artifact_paths["code_result"] == str(code_path)
+        assert artifact_paths["apply_result"] == str(apply_path)
+        assert artifact_paths["review_result"] == str(review_path)
+        evidence = data["evidence"]
+        evidence_text = json.dumps(evidence, ensure_ascii=False)
+        assert "artifacts" not in evidence
+        assert "review_result" not in evidence
+        assert "focused_view" not in evidence
+        assert "focused_graph" not in evidence
+        assert "focused_impact" not in evidence
+        assert "failing test" not in evidence_text
+        evidence_paths = {item["label"]: item["path"] for item in evidence["artifact_paths"]}
+        assert evidence_paths == artifact_paths
+        audit = evidence["audit_summary"]
+        assert audit["review"]["status"] == "skipped"
+        assert audit["plan"]["affected_nodes"] == ["planned"]
+        assert audit["plan"]["code_changes"] == [{"file_path": "scripts/common/run_report.py"}]
+        assert audit["impact"]["result_count"] == 1
+        assert audit["impact"]["mapped_code_relations"] == 1
+        assert audit["code"]["files_modified"] == ["scripts/common/run_report.py"]
+        assert audit["apply"]["status"] == "dep_refreshed"
+        assert audit["apply"]["test_status"] == "failed"
+        assert audit["apply"]["rollback_path"].endswith("dep_graph.before-edit-456.json")
         assert "focused_graph" not in data
         assert not any(item["label"] == "focused_graph" for item in data["artifacts"])
         focused = data["focused_view"]
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index c2fe4e3..d463446 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -61,8 +61,7 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
         "Summary",
         "Stage timeline",
         "Safety boundary",
-        "Why these nodes?",
-        "Focused impact view",
+        "semantic-code impact chain",
         "What changed?",
         "Verification status",
         "Artifact links",
@@ -191,17 +190,15 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     )
 
     html = report.read_text(encoding="utf-8")
-    assert "Why these nodes?" in html
-    assert "Retrieval evidence" in html
+    assert "semantic-code impact chain" in html
+    assert html.count("<h2>semantic-code impact chain</h2>") == 1
+    assert "Why these nodes?" not in html
+    assert "Focused impact view" not in html
     assert "What changed?" in html
-    assert "Focused impact view" in html
-    assert html.count("<h2>Focused impact view</h2>") == 1
-    assert "RPG_EDIT_LOCATE_FILE" in html
-    assert "Primary RPG nodes" in html
-    assert "Primary code nodes" in html
-    assert "Semantic-code mappings" in html
-    assert "Capped neighborhood" in html
-    assert "Hidden context" in html
+    assert "Feature group" in html
+    assert "Semantic → code evidence" in html
+    assert "href=\"#diff-a.py\"" in html
+    assert "id=\"diff-a.py\"" in html
     assert "Inspector JSON" in html
     assert "mapped" in html
     assert "missing" in html
@@ -218,14 +215,20 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "stale_graph" in html
     assert "Hidden 4 additional caller neighbors." in html
     assert '"caller": 1' in html
-    assert '"focused_view"' in html
-    assert "+line 0 &lt;script&gt;alert(0)&lt;/script&gt;" in html
+    assert html.count("+line 0 &lt;script&gt;alert(0)&lt;/script&gt;") == 1
     assert "+line 0 <script>alert(0)</script>" not in html
     assert "Node <unsafe>" not in html
     assert "a.py<script>" not in html
     assert "maps because <reason>" not in html
     assert "<details><summary>View diff</summary>" in html
     assert "<details open" not in html
+    evidence_json = html.split("<summary>Evidence JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
+    assert "code_deltas" not in evidence_json
+    assert "focused_view" not in evidence_json
+    assert "focused_impact" not in evidence_json
+    assert "focused_graph" not in evidence_json
+    assert long_diff not in evidence_json
+    assert len(html) < 18000
     assert "Focused impact summary" not in html
     assert "Focused graph evidence" not in html
     assert "Graph artifact" not in html
@@ -276,6 +279,7 @@ def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Pa
     html = report.read_text(encoding="utf-8")
     assert "Why these nodes?" not in html
     assert "Focused impact view" not in html
+    assert "semantic-code impact chain" not in html
     assert '"dep_nodes": 4' in html
     assert '<td><code>4</code></td>' not in html
 

From 67bea345428ff5bdd38a996602ded51d380f1666 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Fri, 3 Jul 2026 09:01:39 +0000
Subject: [PATCH 19/56] rpg_edit: Extend _feature_evidence_groups() at lines
 510-844 to derive

---
 CoderMind/scripts/common/run_report.py      | 207 ++++++++++++-
 CoderMind/scripts/rpg_edit/review.py        | 303 ++++++++++++++++++--
 CoderMind/tests/test_rpg_edit_run_report.py |  48 +++-
 CoderMind/tests/test_run_report.py          | 119 +++++++-
 4 files changed, 654 insertions(+), 23 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index cd3df68..033b577 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -224,6 +224,9 @@ def _normalize_focused_view(value: Any) -> dict[str, Any]:
         dict(warning) if isinstance(warning, Mapping) else {"message": warning}
         for warning in _as_sequence(value.get("warnings"))
     ]
+    nodes_view = value.get("nodes_view")
+    if isinstance(nodes_view, Mapping):
+        normalized["nodes_view"] = _normalize_nodes_view(nodes_view)
     normalized["unmatched_code_deltas"] = [
         dict(delta) if isinstance(delta, Mapping) else {"file": delta}
         for delta in _as_sequence(value.get("unmatched_code_deltas"))
@@ -231,6 +234,18 @@ def _normalize_focused_view(value: Any) -> dict[str, Any]:
     return normalized
 
 
+def _normalize_nodes_view(value: Mapping[str, Any]) -> dict[str, Any]:
+    normalized = dict(value)
+    normalized["summary"] = dict(value.get("summary") or {}) if isinstance(value.get("summary"), Mapping) else {}
+    for key in ("semantic_nodes", "code_nodes", "mappings", "edges", "warnings", "changed_files"):
+        normalized[key] = [
+            dict(item) if isinstance(item, Mapping) else {"detail": item}
+            for item in _as_sequence(value.get(key))
+        ]
+    normalized["hidden_counts"] = dict(value.get("hidden_counts") or {}) if isinstance(value.get("hidden_counts"), Mapping) else {}
+    return normalized
+
+
 def _normalize_artifacts(value: Any) -> list[dict[str, Any]]:
     artifacts: list[dict[str, Any]] = []
     for item in _as_sequence(value):
@@ -356,6 +371,14 @@ def _render_page(
 .focus-summary {{ display:flex; flex-wrap:wrap; gap:8px; margin-bottom:12px; }}
 .focus-summary .badge {{ background:#eef4ff; color:#174ea6; }}
 .warning-list {{ margin:0 0 12px; padding-left:18px; }}
+.focus-map {{ display:grid; grid-template-columns:repeat(auto-fit,minmax(260px,1fr)); gap:12px; align-items:stretch; }}
+.focus-card {{ border:1px solid var(--line); border-radius:12px; padding:12px; background:#fbfdff; display:flex; flex-direction:column; gap:8px; min-width:0; }}
+.focus-card header {{ margin:0; display:flex; flex-wrap:wrap; gap:8px; align-items:center; }}
+.focus-card-title {{ font-weight:700; overflow-wrap:anywhere; word-break:break-word; }}
+.focus-card-meta {{ color:var(--muted); font-size:13px; overflow-wrap:anywhere; word-break:break-word; }}
+.focus-links {{ display:flex; flex-wrap:wrap; gap:6px; }}
+.focus-link {{ border:1px solid var(--line); border-radius:999px; padding:2px 8px; background:#fff; font-size:12px; }}
+@media (max-width:720px) {{ main {{ padding:22px 12px 36px; }} .focus-map {{ grid-template-columns:1fr; }} table {{ min-width:560px; }} }}
 </style>
 </head>
 <body>
@@ -367,6 +390,7 @@ def _render_page(
 {_render_summary_cards(summary_cards)}
 {_render_timeline(stages)}
 {_render_safety_boundary(user_decisions)}
+{_render_focused_nodes_map(focused_view, code_file_anchors)}
 {_render_semantic_code_impact_chain(retrievals, rpg_nodes, dep_nodes, focused_view, code_file_anchors)}
 {_render_code_deltas(code_deltas, code_delta_anchors)}
 {_render_verification(verification)}
@@ -663,6 +687,9 @@ def _hidden_context_html(hidden_counts: Mapping[str, Any]) -> str:
 
 
 def _focused_inspector_payload(focused_view: Mapping[str, Any]) -> dict[str, Any]:
+    nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
+    if nodes_view:
+        return {"nodes_view": nodes_view}
     payload: dict[str, Any] = {}
     for key, value in focused_view.items():
         if key in {"unmatched_code_deltas"}:
@@ -678,6 +705,184 @@ def _focused_inspector_payload(focused_view: Mapping[str, Any]) -> dict[str, Any
     return payload
 
 
+def _node_view_id(node: Mapping[str, Any]) -> str:
+    return str(node.get("link_id") or node.get("node_id") or node.get("dep_node_id") or "")
+
+
+def _line_range_text(node: Mapping[str, Any]) -> str:
+    line_range = node.get("line_range") if isinstance(node.get("line_range"), Mapping) else {}
+    start = line_range.get("start") or node.get("line_start") or node.get("start_line") or node.get("lineno") or node.get("line")
+    end = line_range.get("end") or node.get("line_end") or node.get("end_line") or start
+    if start in (None, ""):
+        return "unavailable"
+    if end in (None, "") or str(end) == str(start):
+        return str(start)
+    return f"{start}-{end}"
+
+
+def _changed_refs_html(refs: Sequence[Any], file_anchors: Mapping[str, str]) -> str:
+    links = []
+    for ref in _as_sequence(refs):
+        if isinstance(ref, Mapping):
+            path = ref.get("path") or ref.get("file")
+            anchor = ref.get("diff_anchor") or file_anchors.get(str(path or ""))
+        else:
+            path = ref
+            anchor = file_anchors.get(str(path or ""))
+        if path in (None, ""):
+            continue
+        if anchor:
+            links.append(f"<a class=\"focus-link\" href=\"#{_h_attr(anchor)}\">{_h(path)}</a>")
+        else:
+            links.append(f"<span class=\"focus-link\">{_h(path)}</span>")
+    if not links:
+        return ""
+    return '<div class="focus-links">' + "".join(links) + "</div>"
+
+
+def _focus_card_badges(node: Mapping[str, Any], *keys: str) -> str:
+    badges = []
+    for key in keys:
+        value = node.get(key)
+        if value not in (None, "", [], {}):
+            badges.append(f"<span class=\"badge\">{_h(value)}</span>")
+    return "".join(badges)
+
+
+def _semantic_card(node: Mapping[str, Any], file_anchors: Mapping[str, str]) -> str:
+    node_id = node.get("node_id")
+    link_id = _node_view_id(node)
+    title = node.get("name") or node.get("symbol") or node_id or "semantic node"
+    breadcrumb = node.get("breadcrumb_path") or node.get("breadcrumb") or node.get("feature_path") or node.get("path") or "unavailable"
+    mapped = _as_sequence(node.get("mapped_code_node_ids"))
+    mapped_html = ""
+    if mapped:
+        mapped_html = '<div class="focus-card-meta">Mapped code: ' + ", ".join(f"<code>{_h(item)}</code>" for item in mapped) + "</div>"
+    elif (node.get("mapping_status") or node.get("state")) in {"missing", "missing_mapping"}:
+        mapped_html = '<div class="focus-card-meta">Mapped code: <span class="empty">missing mapping</span></div>'
+    warnings = _as_sequence(node.get("warning_types"))
+    warning_html = '<div class="focus-card-meta">Warnings: ' + ", ".join(f"<code>{_h(item)}</code>" for item in warnings) + "</div>" if warnings else ""
+    return (
+        f"<article class=\"focus-card\" id=\"{_h_attr(link_id)}\">"
+        f"<header><span class=\"badge\">semantic</span>{_focus_card_badges(node, 'state', 'mapping_status', 'locate_status')}</header>"
+        f"<div class=\"focus-card-title\">{_h(title)}</div>"
+        f"<div class=\"focus-card-meta\"><code>{_h(node_id)}</code></div>"
+        f"<div class=\"focus-card-meta\">Breadcrumb: {_h(breadcrumb)}</div>"
+        f"<div class=\"focus-card-meta\">Type: {_h(node.get('node_type') or node.get('type') or 'unavailable')}</div>"
+        f"{mapped_html}{warning_html}{_changed_refs_html(_as_sequence(node.get('changed_files')), file_anchors)}"
+        "</article>"
+    )
+
+
+def _code_card(node: Mapping[str, Any], file_anchors: Mapping[str, str]) -> str:
+    node_id = node.get("node_id") or node.get("dep_node_id")
+    link_id = _node_view_id(node)
+    path = node.get("path") or node.get("module") or node.get("file") or "unavailable"
+    symbol = node.get("symbol") or node.get("name") or "unavailable"
+    changed_refs = _as_sequence(node.get("changed_files"))
+    if not changed_refs and node.get("diff_anchor") and path not in (None, "", "unavailable"):
+        changed_refs = [{"path": path, "diff_anchor": node.get("diff_anchor")}]
+    mapped = _as_sequence(node.get("mapped_rpg_node_ids"))
+    mapped_html = '<div class="focus-card-meta">Mapped features: ' + ", ".join(f"<code>{_h(item)}</code>" for item in mapped) + "</div>" if mapped else ""
+    return (
+        f"<article class=\"focus-card\" id=\"{_h_attr(link_id)}\">"
+        f"<header><span class=\"badge\">code</span>{_focus_card_badges(node, 'state', 'source')}</header>"
+        f"<div class=\"focus-card-title\">{_h(symbol)}</div>"
+        f"<div class=\"focus-card-meta\"><code>{_h(node_id)}</code></div>"
+        f"<div class=\"focus-card-meta\">Path: {_h(path)}</div>"
+        f"<div class=\"focus-card-meta\">Type: {_h(node.get('type') or node.get('kind') or 'unavailable')}</div>"
+        f"<div class=\"focus-card-meta\">Lines: {_h(_line_range_text(node))}</div>"
+        f"{mapped_html}{_changed_refs_html(changed_refs, file_anchors)}"
+        "</article>"
+    )
+
+
+def _mapping_card(mapping: Mapping[str, Any]) -> str:
+    target = mapping.get("code_node_id") or mapping.get("dep_node_id") or "missing mapping"
+    source_link = mapping.get("source_link_id")
+    target_link = mapping.get("target_link_id")
+    source_html = f"<a href=\"#{_h_attr(source_link)}\"><code>{_h(mapping.get('rpg_node_id'))}</code></a>" if source_link else f"<code>{_h(mapping.get('rpg_node_id'))}</code>"
+    target_html = f"<a href=\"#{_h_attr(target_link)}\"><code>{_h(target)}</code></a>" if target_link else f"<code>{_h(target)}</code>"
+    return (
+        "<article class=\"focus-card\">"
+        f"<header><span class=\"badge\">mapping</span>{_focus_card_badges(mapping, 'state', 'status', 'source')}</header>"
+        f"<div class=\"focus-card-title\">{source_html} → {target_html}</div>"
+        f"<div class=\"focus-card-meta\">{_h(mapping.get('path') or mapping.get('reason') or '')}</div>"
+        "</article>"
+    )
+
+
+def _edge_endpoint_html(node_id: Any, link_id: Any) -> str:
+    if link_id not in (None, ""):
+        return f"<a href=\"#{_h_attr(link_id)}\"><code>{_h(node_id)}</code></a>"
+    return f"<code>{_h(node_id)}</code>"
+
+
+def _nodes_view_edges_html(edges: Sequence[Mapping[str, Any]]) -> str:
+    edge_rows = []
+    for edge in edges:
+        source = _edge_endpoint_html(edge.get("source_node_id"), edge.get("source_link_id"))
+        target = _edge_endpoint_html(edge.get("target_node_id"), edge.get("target_link_id"))
+        edge_rows.append(
+            "<tr>"
+            f"<td>{source}</td>"
+            f"<td>{target}</td>"
+            f"<td>{_h(edge.get('relation', ''))}</td>"
+            f"<td>{_h(edge.get('direction', ''))}</td>"
+            f"<td>{_h(edge.get('path', ''))}</td>"
+            f"<td>{_h(edge.get('reason', ''))}</td>"
+            "</tr>"
+        )
+    if not edge_rows:
+        return ""
+    return (
+        "<h3>One-hop context</h3>"
+        "<table><thead><tr><th>Source</th><th>Target</th><th>Relation</th><th>Direction</th><th>Path</th><th>Reason</th></tr></thead><tbody>"
+        + "".join(edge_rows)
+        + "</tbody></table>"
+    )
+
+
+def _render_focused_nodes_map(focused_view: dict[str, Any], file_anchors: Mapping[str, str]) -> str:
+    nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
+    if not nodes_view:
+        return ""
+    summary = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else {}
+    summary_html = _summary_badges(summary, [
+        ("Semantic nodes", "semantic_nodes", len(_as_sequence(nodes_view.get("semantic_nodes")))),
+        ("Code nodes", "code_nodes", len(_as_sequence(nodes_view.get("code_nodes")))),
+        ("Mappings", "mappings", len(_as_sequence(nodes_view.get("mappings")))),
+        ("Edges", "edges", len(_as_sequence(nodes_view.get("edges")))),
+        ("Warnings", "warnings", len(_as_sequence(nodes_view.get("warnings")))),
+    ])
+    semantic_cards = [
+        _semantic_card(node, file_anchors)
+        for node in _as_sequence(nodes_view.get("semantic_nodes"))
+        if isinstance(node, Mapping)
+    ]
+    code_cards = [
+        _code_card(node, file_anchors)
+        for node in _as_sequence(nodes_view.get("code_nodes"))
+        if isinstance(node, Mapping)
+    ]
+    mapping_cards = [
+        _mapping_card(mapping)
+        for mapping in _as_sequence(nodes_view.get("mappings"))
+        if isinstance(mapping, Mapping)
+    ]
+    edge_rows = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
+    hidden_html = _hidden_context_html(nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else {})
+    warnings = [warning for warning in _as_sequence(nodes_view.get("warnings")) if isinstance(warning, Mapping)]
+    warnings_html = f"<h3>Warnings</h3>{_chain_warning_html(warnings)}" if warnings else ""
+    body = summary_html
+    if semantic_cards or code_cards or mapping_cards:
+        body += '<div class="focus-map">' + "".join(semantic_cards + code_cards + mapping_cards) + "</div>"
+    else:
+        body += '<p class="empty">No focused nodes map rows recorded.</p>'
+    body += _nodes_view_edges_html(edge_rows) + hidden_html + warnings_html + _focused_graph_metadata(focused_view)
+    return f"<section><h2>Focused nodes map</h2>{body}</section>"
+
+
 def _render_feature_chain_rows(focused_view: dict[str, Any], file_anchors: Mapping[str, str]) -> str:
     rpg_nodes = [node for node in _as_sequence(focused_view.get("primary_rpg_nodes")) if isinstance(node, Mapping)]
     code_nodes = [node for node in _as_sequence(focused_view.get("primary_code_nodes")) if isinstance(node, Mapping)]
@@ -862,7 +1067,7 @@ def _render_semantic_code_impact_chain(
         ])
         hidden_counts = focused_view.get("hidden_counts") if isinstance(focused_view.get("hidden_counts"), Mapping) else {}
         hidden_html = _hidden_context_html(hidden_counts)
-        inspector_html = _focused_graph_metadata(focused_view)
+        inspector_html = "" if isinstance(focused_view.get("nodes_view"), Mapping) else _focused_graph_metadata(focused_view)
         body = f"{summary_html}{_render_feature_chain_rows(focused_view, file_anchors)}{hidden_html}{inspector_html}"
     else:
         body = _render_legacy_chain_rows(retrievals, rpg_nodes, dep_nodes)
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 364ed3d..3213a3a 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -21,6 +21,7 @@
 import argparse
 import json
 import logging
+import re
 import shutil
 import sys
 import time
@@ -337,6 +338,209 @@ def _code_delta_file(delta: Dict[str, Any]) -> str:
     return str(delta.get("file") or delta.get("path") or "")
 
 
+def _diff_anchor_slug(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("._-") or "change"
+
+
+def _diff_anchor_map(code_deltas: List[Dict[str, Any]]) -> Dict[str, str]:
+    anchors: Dict[str, str] = {}
+    used: Dict[str, int] = {}
+    for index, delta in enumerate(code_deltas, start=1):
+        file_path = _code_delta_file(delta) or f"change-{index}"
+        base = _diff_anchor_slug(f"diff-{file_path}")
+        count = used.get(base, 0) + 1
+        used[base] = count
+        anchor = base if count == 1 else f"{base}-{count}"
+        if file_path not in anchors:
+            anchors[file_path] = anchor
+    return anchors
+
+
+def _changed_file_refs(files: List[Any], anchors: Dict[str, str]) -> List[Dict[str, Any]]:
+    refs: List[Dict[str, Any]] = []
+    for file_path in _ordered_unique(files):
+        row = {"path": file_path}
+        _set_if_present(row, "diff_anchor", anchors.get(file_path))
+        refs.append(row)
+    return refs
+
+
+def _node_state(row: Dict[str, Any], default: str = "available") -> str:
+    status = row.get("state") or row.get("status") or row.get("mapping_status")
+    if status in (None, ""):
+        return default
+    if status == "missing":
+        return "missing_mapping"
+    return str(status)
+
+
+def _node_link_id(kind: str, node_id: Any) -> str:
+    return _slug_id(kind, node_id)
+
+
+def _edge_endpoint_link_id(node_id: Any, rpg_nodes: Dict[str, Dict[str, Any]], code_nodes: Dict[str, Dict[str, Any]]) -> str:
+    node_text = str(node_id or "")
+    if node_text in rpg_nodes:
+        return str(rpg_nodes[node_text].get("link_id") or _node_link_id("rpg", node_text))
+    if node_text in code_nodes:
+        return str(code_nodes[node_text].get("link_id") or _node_link_id("code", node_text))
+    return _node_link_id("context", node_text)
+
+
+def _warning_link_fields(warning: Dict[str, Any], rpg_nodes: Dict[str, Dict[str, Any]], code_nodes: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+    row = dict(warning)
+    node_id = warning.get("node_id") or warning.get("rpg_node_id")
+    dep_id = warning.get("dep_node_id") or warning.get("code_node_id")
+    if node_id not in (None, "") and str(node_id) in rpg_nodes:
+        row["node_link_id"] = _edge_endpoint_link_id(node_id, rpg_nodes, code_nodes)
+    if dep_id not in (None, "") and str(dep_id) in code_nodes:
+        row["code_link_id"] = _edge_endpoint_link_id(dep_id, rpg_nodes, code_nodes)
+    return row
+
+
+def _build_nodes_view(
+    primary_rpg_nodes: List[Dict[str, Any]],
+    primary_code_nodes: List[Dict[str, Any]],
+    mappings: List[Dict[str, Any]],
+    edges: List[Dict[str, Any]],
+    hidden_counts: Dict[str, Any],
+    warnings: List[Dict[str, Any]],
+    changed_files: List[str],
+    diff_anchors: Dict[str, str],
+) -> Dict[str, Any]:
+    rpg_by_id = {str(row.get("node_id")): row for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
+    code_by_id = {str(row.get("node_id") or row.get("dep_node_id")): row for row in primary_code_nodes if (row.get("node_id") or row.get("dep_node_id")) not in (None, "")}
+    code_ids_by_rpg: Dict[str, List[str]] = {}
+    warnings_by_rpg: Dict[str, List[Dict[str, Any]]] = {}
+    warnings_by_code: Dict[str, List[Dict[str, Any]]] = {}
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        if rpg_id not in (None, "") and code_id not in (None, ""):
+            code_ids_by_rpg.setdefault(str(rpg_id), []).append(str(code_id))
+    for warning in warnings:
+        if not isinstance(warning, dict):
+            continue
+        rpg_id = warning.get("node_id") or warning.get("rpg_node_id")
+        code_id = warning.get("dep_node_id") or warning.get("code_node_id")
+        if rpg_id not in (None, ""):
+            warnings_by_rpg.setdefault(str(rpg_id), []).append(warning)
+        if code_id not in (None, ""):
+            warnings_by_code.setdefault(str(code_id), []).append(warning)
+
+    semantic_nodes: List[Dict[str, Any]] = []
+    for node in primary_rpg_nodes:
+        node_id = str(node.get("node_id") or "")
+        row: Dict[str, Any] = {
+            "node_id": node_id,
+            "link_id": node.get("link_id") or _node_link_id("rpg", node_id),
+            "state": _node_state(node),
+            "mapping_status": node.get("mapping_status") or node.get("status"),
+        }
+        for key in ("name", "symbol", "type", "node_type", "path", "feature_path", "breadcrumb", "breadcrumb_path", "locate_status", "score", "reason", "apply_action"):
+            _set_if_present(row, key, node.get(key))
+        changed_refs = _changed_file_refs(_listify(node.get("changed_files")) or _listify(node.get("affected_files")), diff_anchors)
+        if changed_refs:
+            row["changed_files"] = changed_refs
+        if isinstance(node.get("hidden_counts"), dict):
+            row["hidden_counts"] = node.get("hidden_counts")
+        mapped_code_ids = _ordered_unique(code_ids_by_rpg.get(node_id, []))
+        if mapped_code_ids:
+            row["mapped_code_node_ids"] = mapped_code_ids
+            row["mapped_code_link_ids"] = [_edge_endpoint_link_id(code_id, rpg_by_id, code_by_id) for code_id in mapped_code_ids]
+        if warnings_by_rpg.get(node_id):
+            row["warning_types"] = _ordered_unique([warning.get("type") for warning in warnings_by_rpg[node_id]])
+        semantic_nodes.append(row)
+
+    code_nodes: List[Dict[str, Any]] = []
+    for node in primary_code_nodes:
+        code_id = str(node.get("node_id") or node.get("dep_node_id") or "")
+        path = node.get("path") or _dep_node_path(code_id)
+        row = {
+            "node_id": code_id,
+            "dep_node_id": code_id,
+            "link_id": node.get("link_id") or _node_link_id("code", code_id),
+            "state": _node_state(node, "mapped"),
+        }
+        for key in ("name", "symbol", "type", "kind", "path", "module", "file", "signature", "source", "source_feature", "source_features", "breadcrumb"):
+            _set_if_present(row, key, node.get(key))
+        _set_if_present(row, "path", path)
+        line_range = node.get("line_range") if isinstance(node.get("line_range"), dict) else _line_range_from(node)
+        if line_range:
+            row["line_range"] = line_range
+        changed_refs = _changed_file_refs([path] if path in diff_anchors else [], diff_anchors)
+        if changed_refs:
+            row["changed"] = True
+            row["changed_files"] = changed_refs
+            row["diff_anchor"] = changed_refs[0].get("diff_anchor")
+        rpg_ids = _ordered_unique([mapping.get("rpg_node_id") for mapping in mappings if (mapping.get("code_node_id") or mapping.get("dep_node_id")) == code_id])
+        if rpg_ids:
+            row["mapped_rpg_node_ids"] = rpg_ids
+            row["mapped_rpg_link_ids"] = [_edge_endpoint_link_id(rpg_id, rpg_by_id, code_by_id) for rpg_id in rpg_ids]
+        if warnings_by_code.get(code_id):
+            row["warning_types"] = _ordered_unique([warning.get("type") for warning in warnings_by_code[code_id]])
+        code_nodes.append(row)
+
+    mapping_rows: List[Dict[str, Any]] = []
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        row: Dict[str, Any] = {
+            "link_id": _node_link_id("map", f"{rpg_id}-{code_id or 'missing'}"),
+            "rpg_node_id": rpg_id,
+            "source_link_id": _edge_endpoint_link_id(rpg_id, rpg_by_id, code_by_id),
+            "status": mapping.get("status") or "mapped",
+            "state": _node_state(mapping, "mapped"),
+        }
+        if code_id not in (None, ""):
+            row["code_node_id"] = code_id
+            row["dep_node_id"] = code_id
+            row["target_link_id"] = _edge_endpoint_link_id(code_id, rpg_by_id, code_by_id)
+        else:
+            row["target_state"] = "missing_mapping"
+        for key in ("source", "path", "reason"):
+            _set_if_present(row, key, mapping.get(key))
+        changed_refs = _changed_file_refs(_listify(mapping.get("changed_files")), diff_anchors)
+        if changed_refs:
+            row["changed_files"] = changed_refs
+        mapping_rows.append(row)
+
+    edge_rows: List[Dict[str, Any]] = []
+    for edge in edges:
+        source_id = edge.get("source_node_id")
+        target_id = edge.get("target_node_id")
+        row: Dict[str, Any] = {
+            "source_node_id": source_id,
+            "target_node_id": target_id,
+            "source_link_id": _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
+            "target_link_id": _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
+            "relation": edge.get("relation") or "dependency",
+            "state": edge.get("status") or "visible",
+        }
+        for key in ("direction", "source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
+            _set_if_present(row, key, edge.get(key))
+        edge_rows.append(row)
+
+    warning_rows = [_warning_link_fields(warning, rpg_by_id, code_by_id) for warning in warnings if isinstance(warning, dict)]
+    return {
+        "summary": {
+            "semantic_nodes": len(semantic_nodes),
+            "code_nodes": len(code_nodes),
+            "mappings": len(mapping_rows),
+            "edges": len(edge_rows),
+            "warnings": len(warning_rows),
+            "changed_files": len(changed_files),
+        },
+        "semantic_nodes": semantic_nodes,
+        "code_nodes": code_nodes,
+        "mappings": mapping_rows,
+        "edges": edge_rows,
+        "hidden_counts": hidden_counts,
+        "warnings": warning_rows,
+        "changed_files": _changed_file_refs(changed_files, diff_anchors),
+    }
+
+
 _FOCUSED_RPG_NODE_CAP = 20
 _FOCUSED_CODE_NODE_CAP = 50
 _FOCUSED_EDGE_CAP = 80
@@ -357,20 +561,54 @@ def _focus_reason(candidate: Dict[str, Any], impact: Dict[str, Any]) -> str:
     return ""
 
 
+def _slug_id(prefix: str, value: Any) -> str:
+    raw = str(value or prefix)
+    slug = re.sub(r"[^A-Za-z0-9_.-]+", "-", raw).strip(".-_")
+    return f"{prefix}-{slug or 'node'}"
+
+
+def _line_range_from(row: Dict[str, Any]) -> Dict[str, Any]:
+    start = row.get("line_start") or row.get("start_line") or row.get("lineno") or row.get("line")
+    end = row.get("line_end") or row.get("end_line") or start
+    line_range: Dict[str, Any] = {}
+    _set_if_present(line_range, "start", start)
+    _set_if_present(line_range, "end", end)
+    return line_range
+
+
+def _symbol_from_dep(dep_id: str, row: Dict[str, Any]) -> str:
+    for key in ("symbol", "name", "qualname", "qualified_name"):
+        value = row.get(key)
+        if value not in (None, ""):
+            return str(value)
+    dep_text = str(dep_id)
+    return dep_text.rsplit(":", 1)[-1] if ":" in dep_text else dep_text
+
+
 def _rpg_node_entry(node_id: str, raw: Dict[str, Any]) -> Dict[str, Any]:
     meta = raw.get("meta") if isinstance(raw.get("meta"), dict) else {}
-    row: Dict[str, Any] = {"node_id": node_id}
-    _set_if_present(row, "name", raw.get("name"))
-    _set_if_present(row, "node_type", raw.get("node_type") or raw.get("type") or raw.get("type_name"))
-    _set_if_present(row, "path", raw.get("path") or raw.get("file") or meta.get("path"))
-    _set_if_present(row, "feature_path", raw.get("feature_path") or meta.get("feature_path"))
+    row: Dict[str, Any] = {"node_id": node_id, "link_id": _slug_id("rpg", node_id)}
+    name = raw.get("name") or raw.get("title")
+    node_type = raw.get("node_type") or raw.get("type") or raw.get("type_name")
+    path = raw.get("path") or raw.get("file") or meta.get("path")
+    feature_path = raw.get("feature_path") or meta.get("feature_path") or raw.get("breadcrumb") or meta.get("breadcrumb")
+    _set_if_present(row, "name", name)
+    _set_if_present(row, "symbol", raw.get("symbol") or name)
+    _set_if_present(row, "node_type", node_type)
+    _set_if_present(row, "type", node_type)
+    _set_if_present(row, "path", path)
+    _set_if_present(row, "feature_path", feature_path)
+    _set_if_present(row, "breadcrumb", feature_path or path)
     return row
 
 
 def _dep_node_entry(dep_id: str, raw: Dict[str, Any]) -> Dict[str, Any]:
-    row: Dict[str, Any] = {"node_id": dep_id, "dep_node_id": dep_id}
+    row: Dict[str, Any] = {"node_id": dep_id, "dep_node_id": dep_id, "link_id": _slug_id("code", dep_id)}
     for key in (
         "name",
+        "symbol",
+        "qualname",
+        "qualified_name",
         "type",
         "kind",
         "module",
@@ -386,7 +624,12 @@ def _dep_node_entry(dep_id: str, raw: Dict[str, Any]) -> Dict[str, Any]:
     ):
         _set_if_present(row, key, raw.get(key))
     if not row.get("path"):
-        _set_if_present(row, "path", row.get("module") or row.get("file") or _dep_node_path(dep_id))
+        _set_if_present(row, "path", row.get("file") or _dep_node_path(dep_id) or row.get("module"))
+    row["symbol"] = _symbol_from_dep(dep_id, row)
+    _set_if_present(row, "breadcrumb", row.get("path"))
+    line_range = _line_range_from(row)
+    if line_range:
+        row["line_range"] = line_range
     return row
 
 
@@ -420,31 +663,39 @@ def _current_rpg_context() -> Tuple[
 
     rpg_nodes: Dict[str, Dict[str, Any]] = {}
 
-    def visit_rpg_node(raw: Any) -> None:
+    def visit_rpg_node(raw: Any, breadcrumb: List[str]) -> None:
         if not isinstance(raw, dict):
             return
+        name = raw.get("name") or raw.get("title")
+        node_breadcrumb = breadcrumb + ([str(name)] if name not in (None, "") else [])
         node_id = raw.get("id") or raw.get("node_id")
         if node_id not in (None, ""):
-            rpg_nodes[str(node_id)] = _rpg_node_entry(str(node_id), raw)
+            row = _rpg_node_entry(str(node_id), raw)
+            if node_breadcrumb:
+                row["breadcrumb"] = node_breadcrumb
+                row["breadcrumb_path"] = " / ".join(node_breadcrumb)
+            rpg_nodes[str(node_id)] = row
         children = raw.get("children") or []
         if isinstance(children, dict):
             children = list(children.values())
         if isinstance(children, (list, tuple)):
             for child in children:
-                visit_rpg_node(child)
+                visit_rpg_node(child, node_breadcrumb)
 
-    visit_rpg_node(rpg_data.get("root"))
+    visit_rpg_node(rpg_data.get("root"), [])
     raw_rpg_nodes = rpg_data.get("nodes")
     if isinstance(raw_rpg_nodes, dict):
         for node_id, raw in raw_rpg_nodes.items():
             raw_dict = raw if isinstance(raw, dict) else {}
-            rpg_nodes[str(node_id)] = _rpg_node_entry(str(node_id), raw_dict)
+            existing = rpg_nodes.get(str(node_id), {})
+            rpg_nodes[str(node_id)] = {**_rpg_node_entry(str(node_id), raw_dict), **existing}
     elif isinstance(raw_rpg_nodes, (list, tuple)):
         for raw in raw_rpg_nodes:
             if isinstance(raw, dict):
                 node_id = raw.get("id") or raw.get("node_id")
                 if node_id not in (None, ""):
-                    rpg_nodes[str(node_id)] = _rpg_node_entry(str(node_id), raw)
+                    existing = rpg_nodes.get(str(node_id), {})
+                    rpg_nodes[str(node_id)] = {**_rpg_node_entry(str(node_id), raw), **existing}
 
     dep_graph = rpg_data.get("dep_graph") if isinstance(rpg_data.get("dep_graph"), dict) else {}
     dep_nodes: Dict[str, Dict[str, Any]] = {}
@@ -580,8 +831,11 @@ def add_code_node(dep_id: Any, *, source_feature: Any = None, source: str = "map
         row = dict(current) if current else {"node_id": dep_id_text, "dep_node_id": dep_id_text}
         row.setdefault("node_id", dep_id_text)
         row.setdefault("dep_node_id", dep_id_text)
+        row.setdefault("link_id", _node_link_id("code", dep_id_text))
+        row.setdefault("symbol", _symbol_from_dep(dep_id_text, row))
         _set_if_present(row, "path", fallback_path)
         row["status"] = "mapped"
+        row["graph_state"] = "available" if dep_id_text in current_dep_nodes else "unavailable"
         row["source"] = source
         if source_feature not in (None, ""):
             row["source_feature"] = str(source_feature)
@@ -590,6 +844,7 @@ def add_code_node(dep_id: Any, *, source_feature: Any = None, source: str = "map
             row["changed"] = True
         if current_graph_available and dep_id_text not in current_dep_nodes:
             row["status"] = "stale_graph"
+            row["graph_state"] = "stale_graph"
             add_warning("stale_graph", "Mapped code node is absent from the current dependency graph", dep_node_id=dep_id_text)
         code_node_by_id[dep_id_text] = row
 
@@ -699,13 +954,18 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
                 impact_hidden_counts[impact_key] = impact_hidden_counts.get(impact_key, 0) + hidden
 
         apply_row = applied_by_id.get(node_id, {})
-        rpg_row: Dict[str, Any] = {
-            "node_id": node_id,
-            "status": "mapped" if mapped_dep_ids else "missing",
-            "mapping_status": "mapped" if mapped_dep_ids else "missing",
-        }
+        rpg_row: Dict[str, Any] = dict(current_node) if current_node else {"node_id": node_id, "link_id": _node_link_id("rpg", node_id)}
+        rpg_row["node_id"] = node_id
+        rpg_row.setdefault("link_id", _node_link_id("rpg", node_id))
+        rpg_row["status"] = "mapped" if mapped_dep_ids else "missing"
+        rpg_row["mapping_status"] = "mapped" if mapped_dep_ids else "missing"
+        rpg_row["graph_state"] = "available" if node_id in current_rpg_nodes else "unavailable"
+        if current_graph_available and node_id not in current_rpg_nodes:
+            rpg_row["graph_state"] = "stale_graph"
         _set_if_present(rpg_row, "name", candidate.get("name") or impact.get("name") or current_node.get("name"))
+        _set_if_present(rpg_row, "symbol", candidate.get("symbol") or impact.get("symbol") or rpg_row.get("name"))
         _set_if_present(rpg_row, "node_type", candidate.get("node_type") or candidate.get("type_name") or candidate.get("type") or current_node.get("node_type"))
+        _set_if_present(rpg_row, "type", rpg_row.get("node_type"))
         _set_if_present(rpg_row, "path", candidate.get("path") or candidate.get("meta_path") or current_node.get("path"))
         _set_if_present(rpg_row, "feature_path", candidate.get("feature_path") or current_node.get("feature_path"))
         _set_if_present(rpg_row, "score", candidate.get("score"))
@@ -803,6 +1063,8 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
     unmatched_code_deltas = [delta for delta in code_deltas if _code_delta_file(delta) not in matched_files]
     mapped_code_relations = sum(1 for row in mapping_rows_all if row.get("code_node_id"))
     missing_mappings = sum(1 for row in mapping_rows_all if row.get("status") == "missing")
+    diff_anchors = _diff_anchor_map(code_deltas)
+    nodes_view = _build_nodes_view(primary_rpg_nodes, primary_code_nodes, mappings, edges, hidden_counts, warnings, changed_files, diff_anchors)
     summary = {
         "selected_feature_groups": len(primary_rpg_nodes_all),
         "primary_rpg_nodes": len(primary_rpg_nodes),
@@ -816,8 +1078,13 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         "apply_status": _apply_status(apply_result),
         "verification_status": _test_status(result, code_result, apply_result),
     }
+    nodes_summary = dict(nodes_view.get("summary", {}))
+    for key in ("selected_feature_groups", "mapped_code_relations", "missing_mappings", "review_status", "apply_status", "verification_status"):
+        _set_if_present(nodes_summary, key, summary.get(key))
+    nodes_view["summary"] = nodes_summary
     return {
         "summary": summary,
+        "nodes_view": nodes_view,
         "primary_rpg_nodes": primary_rpg_nodes,
         "primary_code_nodes": primary_code_nodes,
         "mappings": mappings,
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 9022b72..b38ce32 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -159,7 +159,7 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
             },
             "edges": [],
             "dep_graph": {
-                "nodes": {"a.py:f": {"name": "f", "type": "function", "module": "a.py", "rpg_nodes": ["n1"]}},
+                "nodes": {"a.py:f": {"name": "f", "type": "function", "module": "a.py", "line_start": 10, "line_end": 12, "rpg_nodes": ["n1"]}},
                 "edges": [],
             },
             "_dep_to_rpg_map": {"a.py:f": ["n1"]},
@@ -231,6 +231,7 @@ def fake_write_command_report(run):
         assert "artifacts" not in evidence
         assert "review_result" not in evidence
         assert "focused_view" not in evidence
+        assert "nodes_view" not in evidence_text
         assert "focused_graph" not in evidence
         assert "focused_impact" not in evidence
         assert "+new <unsafe>" not in evidence_text
@@ -269,6 +270,30 @@ def fake_write_command_report(run):
         assert mapped["rpg_node_id"] == "n1"
         assert mapped["changed_files"] == ["a.py"]
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in focused["warnings"])
+        nodes_view = focused["nodes_view"]
+        assert nodes_view["summary"]["selected_feature_groups"] == 2
+        semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
+        assert semantic_by_id["n1"]["breadcrumb_path"] == "Node"
+        assert semantic_by_id["n1"]["mapping_status"] == "mapped"
+        assert semantic_by_id["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
+        assert semantic_by_id["n1"]["hidden_counts"]["callers"] == 1
+        assert semantic_by_id["n2"]["breadcrumb_path"] == "Node / Missing Node"
+        assert semantic_by_id["n2"]["state"] == "missing_mapping"
+        assert semantic_by_id["n2"]["mapping_status"] == "missing"
+        code = nodes_view["code_nodes"][0]
+        assert code["dep_node_id"] == "a.py:f"
+        assert code["path"] == "a.py"
+        assert code["symbol"] == "f"
+        assert code["type"] == "function"
+        assert code["line_range"] == {"start": 10, "end": 12}
+        assert code["diff_anchor"] == "diff-a.py"
+        bridge_by_rpg = {row["rpg_node_id"]: row for row in nodes_view["mappings"]}
+        assert bridge_by_rpg["n1"]["status"] == "mapped"
+        assert bridge_by_rpg["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
+        assert bridge_by_rpg["n2"]["state"] == "missing_mapping"
+        assert nodes_view["hidden_counts"]["callers"] == 1
+        assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in nodes_view["warnings"])
+        assert "+new <unsafe>" not in json.dumps(nodes_view, ensure_ascii=False)
         return report_path
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
@@ -320,7 +345,7 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
             "root": {"id": "planned", "name": "Planned Node", "node_type": "feature", "meta": {"path": "scripts/common/run_report.py"}, "children": []},
             "edges": [],
             "dep_graph": {
-                "nodes": {dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "rpg_nodes": ["planned"]}},
+                "nodes": {dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "line_start": 537, "line_end": 564, "rpg_nodes": ["planned"]}},
                 "edges": [],
             },
             "_dep_to_rpg_map": {dep_id: ["planned"]},
@@ -380,6 +405,7 @@ def fake_write_command_report(run):
         assert "artifacts" not in evidence
         assert "review_result" not in evidence
         assert "focused_view" not in evidence
+        assert "nodes_view" not in evidence_text
         assert "focused_graph" not in evidence
         assert "focused_impact" not in evidence
         assert "failing test" not in evidence_text
@@ -408,6 +434,24 @@ def fake_write_command_report(run):
         mapping = focused["mappings"][0]
         assert mapping["code_node_id"] == dep_id
         assert "impact" in mapping["source"]
+        nodes_view = focused["nodes_view"]
+        assert nodes_view["summary"]["selected_feature_groups"] == 1
+        semantic = nodes_view["semantic_nodes"][0]
+        assert semantic["node_id"] == "planned"
+        assert semantic["breadcrumb_path"] == "Planned Node"
+        assert semantic["locate_status"] == "missing"
+        assert semantic["mapping_status"] == "mapped"
+        assert semantic["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
+        code = nodes_view["code_nodes"][0]
+        assert code["dep_node_id"] == dep_id
+        assert code["path"] == "scripts/common/run_report.py"
+        assert code["symbol"] == "_render_artifacts"
+        assert code["line_range"] == {"start": 537, "end": 564}
+        assert code["diff_anchor"] == "diff-scripts_common_run_report.py"
+        bridge = nodes_view["mappings"][0]
+        assert bridge["status"] == "mapped"
+        assert bridge["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
+        assert any(row["type"] == "missing_reason" and row["node_id"] == "planned" for row in nodes_view["warnings"])
         assert focused["apply"]["status"] == "dep_refreshed"
         return report_path
 
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index d463446..d7c6764 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -61,6 +61,7 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
         "Summary",
         "Stage timeline",
         "Safety boundary",
+        "Focused nodes map",
         "semantic-code impact chain",
         "What changed?",
         "Verification status",
@@ -122,6 +123,103 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
                     "edges": 2,
                     "warnings": 4,
                 },
+                "nodes_view": {
+                    "summary": {
+                        "semantic_nodes": 2,
+                        "code_nodes": 1,
+                        "mappings": 2,
+                        "edges": 2,
+                        "warnings": 4,
+                    },
+                    "semantic_nodes": [
+                        {
+                            "node_id": "n1<script>",
+                            "link_id": "rpg-n1-script",
+                            "name": "Node <unsafe>",
+                            "symbol": "NodeSymbol <unsafe>",
+                            "node_type": "feature<script>",
+                            "breadcrumb": ["Root", "Feature <unsafe>"],
+                            "breadcrumb_path": "Root / Feature <unsafe>",
+                            "state": "mapped",
+                            "mapping_status": "mapped",
+                            "reason": "selected <reason>",
+                            "mapped_code_node_ids": ["a.py:f<script>"],
+                            "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
+                            "hidden_counts": {"callers": 3},
+                        },
+                        {
+                            "node_id": "n2",
+                            "link_id": "rpg-n2",
+                            "name": "Missing <mapping>",
+                            "breadcrumb_path": "Root / Missing <path>",
+                            "state": "missing_mapping",
+                            "mapping_status": "missing",
+                            "warning_types": ["missing_mapping"],
+                        },
+                    ],
+                    "code_nodes": [
+                        {
+                            "node_id": "a.py:f<script>",
+                            "dep_node_id": "a.py:f<script>",
+                            "link_id": "code-a.py-f-script",
+                            "symbol": "func <unsafe>",
+                            "path": "a.py",
+                            "type": "function<script>",
+                            "line_range": {"start": 10, "end": 12},
+                            "state": "mapped",
+                            "source": "locate<unsafe>",
+                            "mapped_rpg_node_ids": ["n1<script>"],
+                            "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
+                        }
+                    ],
+                    "mappings": [
+                        {
+                            "rpg_node_id": "n1<script>",
+                            "code_node_id": "a.py:f<script>",
+                            "source_link_id": "rpg-n1-script",
+                            "target_link_id": "code-a.py-f-script",
+                            "status": "mapped",
+                            "state": "mapped",
+                            "path": "a.py<script>",
+                            "source": "locate+impact",
+                            "reason": "maps because <reason>",
+                            "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
+                        },
+                        {"rpg_node_id": "n2", "source_link_id": "rpg-n2", "status": "missing", "state": "missing_mapping", "reason": "no dep <reason>"},
+                    ],
+                    "edges": [
+                        {
+                            "source_node_id": "caller<script>",
+                            "target_node_id": "a.py:f<script>",
+                            "source_link_id": "context-caller-script",
+                            "target_link_id": "code-a.py-f-script",
+                            "relation": "caller",
+                            "direction": "upstream",
+                            "path": "caller.py<script>",
+                            "source": "impact",
+                            "reason": "calls <reason>",
+                        },
+                        {
+                            "source_node_id": "a.py:f<script>",
+                            "target_node_id": "callee<script>",
+                            "source_link_id": "code-a.py-f-script",
+                            "target_link_id": "context-callee-script",
+                            "relation": "callee",
+                            "direction": "downstream",
+                            "path": "callee.py<script>",
+                            "source": "impact",
+                            "reason": "reaches <reason>",
+                        },
+                    ],
+                    "hidden_counts": {"callers": 3, "edges": 1, "relations": {"caller": 1}},
+                    "warnings": [
+                        {"type": "missing_mapping", "message": "Missing <mapping>", "node_id": "n2", "node_link_id": "rpg-n2"},
+                        {"type": "missing_reason", "message": "Missing <reason>", "node_id": "n3"},
+                        {"type": "too_many_neighbors", "message": "Too many <neighbors>", "hidden_counts": {"edges": 1}},
+                        {"type": "stale_graph", "message": "Stale <graph>", "dep_node_id": "old.py:f"},
+                    ],
+                    "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
+                },
                 "primary_rpg_nodes": [
                     {
                         "node_id": "n1<script>",
@@ -190,16 +288,27 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     )
 
     html = report.read_text(encoding="utf-8")
+    assert "Focused nodes map" in html
     assert "semantic-code impact chain" in html
+    assert html.count("<h2>Focused nodes map</h2>") == 1
     assert html.count("<h2>semantic-code impact chain</h2>") == 1
     assert "Why these nodes?" not in html
     assert "Focused impact view" not in html
     assert "What changed?" in html
     assert "Feature group" in html
     assert "Semantic → code evidence" in html
+    assert "focus-map" in html
+    assert "One-hop context" in html
+    assert "caller.py&lt;script&gt;" in html
+    assert "Root / Feature &lt;unsafe&gt;" in html
+    assert "NodeSymbol &lt;unsafe&gt;" in html
+    assert "function&lt;script&gt;" in html
+    assert "Lines: 10-12" in html
+    assert "Mapped code:" in html
+    assert "Mapped code: <span class=\"empty\">missing mapping</span>" in html
     assert "href=\"#diff-a.py\"" in html
     assert "id=\"diff-a.py\"" in html
-    assert "Inspector JSON" in html
+    assert html.count("<summary>Inspector JSON</summary>") == 1
     assert "mapped" in html
     assert "missing" in html
     assert "n1&lt;script&gt;" in html
@@ -222,13 +331,19 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "maps because <reason>" not in html
     assert "<details><summary>View diff</summary>" in html
     assert "<details open" not in html
+    inspector_json = html.split("<summary>Inspector JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
+    assert "nodes_view" in inspector_json
+    assert "semantic_nodes" in inspector_json
+    assert "primary_rpg_nodes" not in inspector_json
+    assert "primary_code_nodes" not in inspector_json
+    assert long_diff not in inspector_json
     evidence_json = html.split("<summary>Evidence JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
     assert "code_deltas" not in evidence_json
     assert "focused_view" not in evidence_json
     assert "focused_impact" not in evidence_json
     assert "focused_graph" not in evidence_json
     assert long_diff not in evidence_json
-    assert len(html) < 18000
+    assert len(html) < 22000
     assert "Focused impact summary" not in html
     assert "Focused graph evidence" not in html
     assert "Graph artifact" not in html

From c7d18cd8d1aa732a418da5e57de55e307c420895 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Mon, 6 Jul 2026 05:18:00 +0000
Subject: [PATCH 20/56] rpg_edit: Preserve Step 5b rpg-only apply metadata in
 _record_apply_re

---
 CoderMind/scripts/common/run_report.py      | 66 ---------------
 CoderMind/scripts/rpg_edit/apply.py         | 16 ++++
 CoderMind/scripts/rpg_edit/review.py        | 48 +++++++----
 CoderMind/templates/commands/rpg_edit.md    |  4 +-
 CoderMind/tests/test_rpg_edit_run_report.py | 94 +++++++++++++++++++--
 CoderMind/tests/test_run_report.py          | 10 +++
 6 files changed, 147 insertions(+), 91 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 033b577..6b15004 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -1074,45 +1074,6 @@ def _render_semantic_code_impact_chain(
     return f"<section><h2>semantic-code impact chain</h2>{body}</section>"
 
 
-def _render_why_these_nodes(
-    retrievals: list[dict[str, Any]],
-    rpg_nodes: list[dict[str, Any]],
-    dep_nodes: list[dict[str, Any]],
-) -> str:
-    return _render_semantic_code_impact_chain(retrievals, rpg_nodes, dep_nodes, {}, {})
-
-
-def _render_node_rows(title: str, nodes: list[dict[str, Any]], *, dep_graph: bool) -> str:
-    if not nodes:
-        return f"<h3>{_h(title)}</h3><p class=\"empty\">No node evidence recorded.</p>"
-    rows = []
-    if dep_graph:
-        for node in nodes:
-            dep_id = node.get("dep_node_id") or node.get("node_id")
-            rows.append(
-                "<tr>"
-                f"<td><code>{_h(dep_id)}</code></td>"
-                f"<td>{_h(node.get('path', ''))}</td>"
-                f"<td><code>{_h(node.get('source_feature', ''))}</code></td>"
-                f"<td>{_h(node.get('relation') or node.get('change') or node.get('status', ''))}</td>"
-                "</tr>"
-            )
-        body = "<table><thead><tr><th>Code node</th><th>Path</th><th>Feature</th><th>Relation/state</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
-    else:
-        for node in nodes:
-            rows.append(
-                "<tr>"
-                f"<td><code>{_h(node.get('node_id', ''))}</code></td>"
-                f"<td>{_h(node.get('name', ''))}</td>"
-                f"<td>{_h(node.get('type') or node.get('node_type') or '')}</td>"
-                f"<td>{_h(node.get('path', ''))}</td>"
-                f"<td>{_h(node.get('score') or node.get('status') or '')}</td>"
-                "</tr>"
-            )
-        body = "<table><thead><tr><th>Feature</th><th>Name</th><th>Type</th><th>Path</th><th>Score/state</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
-    return f"<h3>{_h(title)}</h3>{body}"
-
-
 def _focused_graph_metadata(focused_view: dict[str, Any]) -> str:
     data = json.dumps(_focused_inspector_payload(focused_view), indent=2, ensure_ascii=False, default=_json_default)
     return f"<details><summary>Inspector JSON</summary><pre>{_h(data)}</pre></details>"
@@ -1132,33 +1093,6 @@ def _focused_node_cell(node_id: Any, node: Mapping[str, Any] | None) -> str:
     return "".join(parts) or "<span class=\"empty\">missing</span>"
 
 
-def _render_focused_impact(focused_view: dict[str, Any]) -> str:
-    return _render_semantic_code_impact_chain([], [], [], focused_view, {})
-
-
-def _render_focused_impact_group(group: Mapping[str, Any]) -> str:
-    relation = group.get("relation") or "dependency"
-    edges = [edge for edge in _as_sequence(group.get("edges")) if isinstance(edge, Mapping)]
-    hidden = group.get("hidden") or 0
-    edge_rows = []
-    for edge in edges:
-        edge_rows.append(
-            "<tr>"
-            f"<td><code>{_h(edge.get('source_node_id', ''))}</code></td>"
-            f"<td><code>{_h(edge.get('target_node_id', ''))}</code></td>"
-            f"<td>{_h(edge.get('direction', ''))}</td>"
-            f"<td>{_h(edge.get('path', ''))}</td>"
-            f"<td>{_h(edge.get('source', ''))}</td>"
-            f"<td>{_h(edge.get('reason', ''))}</td>"
-            "</tr>"
-        )
-    rows_html = "<p class=\"empty\">No visible rows for this relation.</p>"
-    if edge_rows:
-        rows_html = "<table><thead><tr><th>Source</th><th>Target</th><th>Direction</th><th>Path</th><th>Source</th><th>Reason</th></tr></thead><tbody>" + "".join(edge_rows) + "</tbody></table>"
-    hidden_html = f"<p class=\"reason\">Hidden { _h(hidden) } additional {_h(relation)} neighbors.</p>" if hidden else ""
-    return f"<details><summary>{_h(relation)} neighborhood ({_h(len(edges))} shown)</summary>{hidden_html}{rows_html}</details>"
-
-
 def _render_artifacts(artifacts: list[dict[str, Any]]) -> str:
     if not artifacts:
         body = "<p class=\"empty\">No artifact links recorded.</p>"
diff --git a/CoderMind/scripts/rpg_edit/apply.py b/CoderMind/scripts/rpg_edit/apply.py
index 8f60827..8d3494b 100644
--- a/CoderMind/scripts/rpg_edit/apply.py
+++ b/CoderMind/scripts/rpg_edit/apply.py
@@ -92,6 +92,22 @@ def _record_apply_result(
     confirmed: bool | None = None,
 ) -> Dict[str, Any]:
     backups = backups or {}
+    preserved: Dict[str, Any] = {}
+    if backup_timestamp is not None and RPG_EDIT_APPLY_RESULT_FILE.exists():
+        try:
+            previous = json.loads(RPG_EDIT_APPLY_RESULT_FILE.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            previous = {}
+        if isinstance(previous, dict) and str(previous.get("backup_timestamp")) == str(backup_timestamp):
+            preserved = previous
+    for key in ("applied_features", "backups", "confirmed", "before_state", "rollback_command", "rollback_path"):
+        previous_value = preserved.get(key)
+        if previous_value in (None, "", [], {}):
+            continue
+        if result.get(key) in (None, "", [], {}):
+            result[key] = previous_value
+    if not backups and isinstance(result.get("backups"), dict):
+        backups = result["backups"]
     if backup_timestamp is not None:
         result.setdefault("backup_timestamp", backup_timestamp)
         result.setdefault("rollback_command", _rollback_command(backup_timestamp, before_state))
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 3213a3a..c254481 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -284,19 +284,6 @@ def _code_delta_rows(artifacts: Dict[str, Any]) -> List[Dict[str, Any]]:
     return rows
 
 
-def _focused_graph_artifact(candidates: List[Dict[str, Any]], artifacts: Dict[str, Any]) -> Dict[str, Any]:
-    dep_rows = _dep_node_rows(candidates)
-    selected_rpg = sorted({str(row.get("node_id")) for row in candidates if row.get("node_id")})
-    selected_dep = sorted({str(row.get("node_id")) for row in dep_rows if row.get("node_id")})
-    if not selected_rpg and not selected_dep:
-        return {}
-    return {
-        "status": "embedded",
-        "selected_rpg_nodes": selected_rpg,
-        "selected_dep_nodes": selected_dep,
-    }
-
-
 def _dep_node_path(dep_id: Any) -> str:
     if dep_id in (None, ""):
         return ""
@@ -763,7 +750,6 @@ def _feature_evidence_groups(
     candidates: List[Dict[str, Any]],
     code_deltas: List[Dict[str, Any]],
     result: Dict[str, Any],
-    focused_graph: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     locate = artifacts.get("locate") if isinstance(artifacts.get("locate"), dict) else {}
     plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else {}
@@ -1139,12 +1125,20 @@ def _review_timeline(result: Dict[str, Any], artifacts: Dict[str, Any]) -> List[
     plan = artifacts.get("plan") if isinstance(artifacts.get("plan"), dict) else None
     impact = artifacts.get("impact") if isinstance(artifacts.get("impact"), dict) else None
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else None
+    apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else None
+    apply_reason = "artifact not found"
+    if apply_result is not None:
+        apply_reason = (
+            f"{len(apply_result.get('applied_features') or [])} applied features; "
+            f"dep_graph_refreshed={apply_result.get('dep_graph_refreshed')}"
+        )
     return [
         {"name": "validate", "status": validate.get("type") if validate else "missing", "reason": validate.get("message", "") if validate else "artifact not found"},
         {"name": "locate", "status": locate.get("type") if locate else "missing", "reason": f"{len(locate.get('results') or [])} candidates" if locate else "artifact not found"},
         {"name": "plan", "status": "available" if plan else "missing", "reason": f"{len(plan.get('code_changes') or [])} code changes" if plan else "artifact not found"},
         {"name": "impact", "status": impact.get("type", "available") if impact else "missing", "reason": f"{len((impact.get('results') or {}))} impact result sets" if impact else "artifact not found"},
         {"name": "code", "status": code_result.get("last_status") if code_result else "missing", "reason": code_result.get("last_error") or f"success={code_result.get('success')}" if code_result else "artifact not found"},
+        {"name": "apply/dep-refresh", "status": _apply_status(apply_result or {}), "reason": apply_reason},
         {"name": "review", "status": result.get("type"), "reason": result.get("reason") or f"success={result.get('success')}"},
     ]
 
@@ -1153,10 +1147,30 @@ def _review_verification(result: Dict[str, Any], artifacts: Dict[str, Any]) -> L
     checks: List[Dict[str, Any]] = []
     validate = artifacts.get("validate") if isinstance(artifacts.get("validate"), dict) else None
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else None
+    apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else None
     if validate:
         checks.append({"name": "validate", "status": validate.get("type"), "detail": validate.get("message", "")})
     if code_result:
         checks.append({"name": "code", "status": code_result.get("success"), "detail": code_result.get("last_error") or code_result.get("last_status")})
+    if apply_result is None:
+        checks.append({"name": "apply", "status": "missing", "detail": "artifact not found"})
+    else:
+        checks.append({
+            "name": "apply",
+            "status": _apply_status(apply_result),
+            "detail": f"{len(apply_result.get('applied_features') or [])} applied features",
+        })
+    test_result = apply_result.get("test_result") if isinstance(apply_result, dict) and isinstance(apply_result.get("test_result"), dict) else {}
+    checks.append({
+        "name": "test",
+        "status": _test_status(result, code_result or {}, apply_result or {}),
+        "detail": "apply test_result" if test_result else "review/code status fallback",
+    })
+    checks.append({
+        "name": "dep_graph refresh",
+        "status": apply_result.get("dep_graph_refreshed") if apply_result is not None else "missing",
+        "detail": f"apply status={_apply_status(apply_result or {})}" if apply_result is not None else "artifact not found",
+    })
     checks.append({"name": "review", "status": result.get("success", result.get("type") == "skipped"), "detail": result.get("reason") or result.get("type")})
     for iteration in result.get("iterations") or []:
         checks.append({
@@ -1280,13 +1294,17 @@ def _compact_apply_audit(apply_result: Dict[str, Any]) -> Dict[str, Any]:
         if row:
             applied.append(row)
     test_result = apply_result.get("test_result") if isinstance(apply_result.get("test_result"), dict) else {}
-    return {
+    audit = {
         "status": _apply_status(apply_result),
         "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
         "applied_features": applied,
         "rollback_path": _rollback_path(apply_result),
         "test_status": _status_from_bool(test_result.get("passed")),
     }
+    for key in ("backup_timestamp", "backups", "confirmed", "before_state", "rollback_command"):
+        if apply_result.get(key) not in (None, "", [], {}):
+            audit[key] = apply_result.get(key)
+    return audit
 
 
 def _compact_review_audit(result: Dict[str, Any]) -> Dict[str, Any]:
diff --git a/CoderMind/templates/commands/rpg_edit.md b/CoderMind/templates/commands/rpg_edit.md
index f467237..03c8e4c 100644
--- a/CoderMind/templates/commands/rpg_edit.md
+++ b/CoderMind/templates/commands/rpg_edit.md
@@ -285,7 +285,7 @@ do **not** silently `git stash`, as that would hide their work.
 **Step 5b — Update RPG feature graph:**
 
 ```bash
-cmind script rpg_edit/apply.py --phase rpg-only --json
+cmind script rpg_edit/apply.py --phase rpg-only --confirmed --json
 ```
 
 This applies `feature_changes` to the RPG and saves it (reading the plan
@@ -317,7 +317,7 @@ code + dep_graph land together:
 
 ```bash
 cmind script rpg_edit/apply.py --phase dep-refresh \
-    --backup-ts <timestamp_from_5b> --json
+    --backup-ts <timestamp_from_5b> --confirmed --json
 
 git add -A && git commit --amend --no-edit
 ```
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index b38ce32..8c902e2 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -49,6 +49,44 @@ def test_code_result_is_persisted(tmp_path: Path, monkeypatch) -> None:
     assert data == {"success": True, "commit_sha": "abc123"}
 
 
+def test_apply_result_preserves_rpg_metadata_when_dep_refresh_reuses_backup_ts(tmp_path: Path, monkeypatch) -> None:
+    apply = _load_script("rpg_edit_apply_persist_test", _SCRIPTS / "rpg_edit" / "apply.py")
+
+    result_path = tmp_path / "rpg_edit_apply_result.json"
+    monkeypatch.setattr(apply, "RPG_EDIT_APPLY_RESULT_FILE", result_path)
+    previous = {
+        "type": "rpg_updated",
+        "backup_timestamp": "123",
+        "backups": {"rpg": "rpg.before-edit-123.json"},
+        "applied_features": [{"node_id": "n1", "action": "modified"}],
+        "confirmed": True,
+        "before_state": {"head_commit": "before123"},
+        "rollback_command": "cmind script rpg_edit/apply.py --rollback 123 --rollback-branch rpg-edit/test",
+        "rollback_path": "rpg.before-edit-123.json",
+    }
+    result_path.write_text(json.dumps(previous), encoding="utf-8")
+
+    result = apply._record_apply_result(
+        {"type": "dep_refreshed", "backup_timestamp": "123"},
+        backup_timestamp="123",
+        backups={},
+        applied_features=[],
+        dep_graph_refreshed=True,
+        before_state={"head_commit": "current123"},
+        confirmed=True,
+    )
+
+    assert result["type"] == "dep_refreshed"
+    assert result["applied_features"] == [{"node_id": "n1", "action": "modified"}]
+    assert result["backups"] == {"rpg": "rpg.before-edit-123.json"}
+    assert result["confirmed"] is True
+    assert result["before_state"] == {"head_commit": "before123"}
+    assert result["rollback_command"] == "cmind script rpg_edit/apply.py --rollback 123 --rollback-branch rpg-edit/test"
+    assert result["rollback_path"] == "rpg.before-edit-123.json"
+    assert result["dep_graph_refreshed"] is True
+    assert json.loads(result_path.read_text(encoding="utf-8")) == result
+
+
 def test_code_result_clears_recovered_subagent_error(tmp_path: Path, monkeypatch) -> None:
     code = _load_script("rpg_edit_code_retry_test", _SCRIPTS / "rpg_edit" / "code.py")
 
@@ -204,6 +242,15 @@ def fake_write_command_report(run):
         )
         assert review_artifact["status"] == "available"
         assert apply_artifact["status"] == "available"
+        steps_by_name = {row["name"]: row for row in data["steps"]}
+        assert steps_by_name["apply/dep-refresh"]["status"] == "success"
+        assert "1 applied features" in steps_by_name["apply/dep-refresh"]["reason"]
+        assert "dep_graph_refreshed=True" in steps_by_name["apply/dep-refresh"]["reason"]
+        verification_by_name = {row["name"]: row for row in data["verification"]}
+        assert verification_by_name["apply"]["status"] == "success"
+        assert verification_by_name["apply"]["detail"] == "1 applied features"
+        assert verification_by_name["test"]["status"] == "passed"
+        assert verification_by_name["dep_graph refresh"]["status"] is True
         decision = data["user_decisions"][0]
         assert decision["decision"] == "apply"
         assert decision["branch"] == "rpg-edit/test"
@@ -248,7 +295,13 @@ def fake_write_command_report(run):
         assert audit["code"]["files_modified"] == ["a.py"]
         assert audit["apply"]["status"] == "success"
         assert audit["apply"]["dep_graph_refreshed"] is True
+        assert audit["apply"]["applied_features"] == [{"node_id": "n1", "action": "modified"}]
         assert audit["apply"]["rollback_path"] == str(backup_path)
+        assert audit["apply"]["backup_timestamp"] == "123"
+        assert audit["apply"]["backups"] == {"rpg": str(backup_path)}
+        assert audit["apply"]["confirmed"] is True
+        assert audit["apply"]["before_state"]["head_commit"] == "before123"
+        assert audit["apply"]["rollback_command"] == "cmind script rpg_edit/apply.py --rollback 123"
         assert audit["apply"]["test_status"] == "passed"
         assert "focused_graph" not in data
         assert "focused_impact" not in data
@@ -327,14 +380,23 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
         encoding="utf-8",
     )
     code_path.write_text(json.dumps({"success": True, "files_modified": ["scripts/common/run_report.py"], "last_status": "complete"}), encoding="utf-8")
+    dep_backup_path = tmp_path / "dep_graph.before-edit-456.json"
+    rpg_backup_path = tmp_path / "rpg.before-edit-456.json"
     apply_path.write_text(
         json.dumps({
             "type": "dep_refreshed",
             "backup_timestamp": "456",
-            "backups": {"dep_graph": str(tmp_path / "dep_graph.before-edit-456.json")},
-            "applied_features": [],
+            "backups": {"rpg": str(rpg_backup_path), "dep_graph": str(dep_backup_path)},
+            "applied_features": [{"node_id": "planned", "action": "modified"}],
             "dep_graph_refreshed": True,
-            "rollback_command": "cmind script rpg_edit/apply.py --rollback 456",
+            "rollback_command": "cmind script rpg_edit/apply.py --rollback 456 --rollback-branch rpg-edit/test",
+            "before_state": {
+                "head_commit": "before456",
+                "head_short": "before",
+                "head_branch": "rpg-edit/test",
+                "head_timestamp": "2026-06-30T12:45:00+00:00",
+            },
+            "confirmed": True,
             "test_result": {"passed": False, "output": "failing test"},
         }),
         encoding="utf-8",
@@ -373,14 +435,23 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
 
     def fake_write_command_report(run):
         data = run.to_dict()
+        steps_by_name = {row["name"]: row for row in data["steps"]}
+        assert steps_by_name["apply/dep-refresh"]["status"] == "dep_refreshed"
+        assert "1 applied features" in steps_by_name["apply/dep-refresh"]["reason"]
+        assert "dep_graph_refreshed=True" in steps_by_name["apply/dep-refresh"]["reason"]
+        verification_by_name = {row["name"]: row for row in data["verification"]}
+        assert verification_by_name["apply"]["status"] == "dep_refreshed"
+        assert verification_by_name["apply"]["detail"] == "1 applied features"
+        assert verification_by_name["test"]["status"] == "failed"
+        assert verification_by_name["dep_graph refresh"]["status"] is True
         decision = data["user_decisions"][0]
         assert decision["decision"] == "apply"
-        assert decision["branch"] == "fallback-branch"
-        assert decision["before_state"]["head_commit"] == "current456"
-        assert "confirmed" not in decision
+        assert decision["branch"] == "rpg-edit/test"
+        assert decision["before_state"]["head_commit"] == "before456"
+        assert decision["confirmed"] is True
         assert decision["apply_status"] == "dep_refreshed"
         assert decision["test_status"] == "failed"
-        assert decision["rollback_path"].endswith("dep_graph.before-edit-456.json")
+        assert decision["rollback_path"] == str(rpg_backup_path)
         assert any(item["label"] == "apply_result" for item in data["artifacts"])
         assert data["rpg_deltas"] == [{"node_id": "planned", "name": "Planned Node"}]
         assert data["dep_graph_deltas"] == [
@@ -419,8 +490,15 @@ def fake_write_command_report(run):
         assert audit["impact"]["mapped_code_relations"] == 1
         assert audit["code"]["files_modified"] == ["scripts/common/run_report.py"]
         assert audit["apply"]["status"] == "dep_refreshed"
+        assert audit["apply"]["dep_graph_refreshed"] is True
+        assert audit["apply"]["applied_features"] == [{"node_id": "planned", "action": "modified"}]
         assert audit["apply"]["test_status"] == "failed"
-        assert audit["apply"]["rollback_path"].endswith("dep_graph.before-edit-456.json")
+        assert audit["apply"]["rollback_path"] == str(rpg_backup_path)
+        assert audit["apply"]["backup_timestamp"] == "456"
+        assert audit["apply"]["backups"] == {"rpg": str(rpg_backup_path), "dep_graph": str(dep_backup_path)}
+        assert audit["apply"]["confirmed"] is True
+        assert audit["apply"]["before_state"]["head_commit"] == "before456"
+        assert audit["apply"]["rollback_command"] == "cmind script rpg_edit/apply.py --rollback 456 --rollback-branch rpg-edit/test"
         assert "focused_graph" not in data
         assert not any(item["label"] == "focused_graph" for item in data["artifacts"])
         focused = data["focused_view"]
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index d7c6764..d5e4da4 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -19,9 +19,19 @@
     UserDecisionEvent,
     VerificationEvent,
 )
+import common.run_report as run_report
 from common.run_report import write_command_report
 
 
+def test_run_report_exposes_current_impact_renderers_only() -> None:
+    assert hasattr(run_report, "_render_semantic_code_impact_chain")
+    assert hasattr(run_report, "_render_focused_nodes_map")
+    assert not hasattr(run_report, "_render_why_these_nodes")
+    assert not hasattr(run_report, "_render_node_rows")
+    assert not hasattr(run_report, "_render_focused_impact")
+    assert not hasattr(run_report, "_render_focused_impact_group")
+
+
 def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path) -> None:
     report = write_command_report(
         CommandRun(

From 87cc10dd97fea059b733c87bf6ee9d8af1423502 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Mon, 6 Jul 2026 07:16:09 +0000
Subject: [PATCH 21/56] rpg_edit: Add explicit report publishing scope handling
 around `_publi

---
 CoderMind/scripts/rpg_edit/review.py        | 141 ++++++++++++++++++--
 CoderMind/templates/commands/rpg_edit.md    |   7 +-
 CoderMind/tests/test_rpg_edit_run_report.py | 127 +++++++++++++++++-
 3 files changed, 263 insertions(+), 12 deletions(-)

diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index c254481..2da1859 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -25,6 +25,7 @@
 import shutil
 import sys
 import time
+import uuid
 from pathlib import Path
 from string import Template
 from typing import Any, Dict, List, Optional, Tuple
@@ -93,7 +94,47 @@ def _load_review_artifacts(plan_path: Path, impact_path: Optional[Path]) -> Dict
     }
 
 
-def _artifact_links(plan_path: Path, impact_path: Optional[Path]) -> List[Dict[str, Any]]:
+_REPORT_SCOPES = {"final", "internal", "none"}
+
+
+def _normalize_report_scope(report_scope: str) -> str:
+    scope = str(report_scope or "final").strip().lower()
+    if scope not in _REPORT_SCOPES:
+        raise ValueError(f"report_scope must be one of {sorted(_REPORT_SCOPES)}, got {report_scope!r}")
+    return scope
+
+
+def _report_target_dir(report_scope: str, report_dir: Optional[Path]) -> Path:
+    base_dir = Path(report_dir) if report_dir is not None else REPORTS_DIR
+    return base_dir / "internal" if report_scope == "internal" else base_dir
+
+
+def _report_filename_slug(value: str) -> str:
+    slug = re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("._-")
+    return slug or "command"
+
+
+def _expected_report_path(report_dir: Path, run_id: str) -> Path:
+    return report_dir / f"cmind_run_rpg_edit_{_report_filename_slug(run_id)}.html"
+
+
+def _load_existing_review_result() -> Dict[str, Any]:
+    result = _load_json_artifact(RPG_EDIT_REVIEW_RESULT_FILE)
+    return result if isinstance(result, dict) else {}
+
+
+def _existing_internal_report_paths(result: Dict[str, Any]) -> List[str]:
+    paths = _listify(result.get("internal_report_paths"))
+    if result.get("report_scope") == "internal" and result.get("report_path"):
+        paths.extend(_listify(result.get("report_path")))
+    return _ordered_unique(paths)
+
+
+def _artifact_links(
+    plan_path: Path,
+    impact_path: Optional[Path],
+    internal_report_paths: Optional[List[str]] = None,
+) -> List[Dict[str, Any]]:
     paths = {
         "validate": RPG_EDIT_VALIDATE_FILE,
         "locate": RPG_EDIT_LOCATE_FILE,
@@ -109,6 +150,12 @@ def _artifact_links(plan_path: Path, impact_path: Optional[Path]) -> List[Dict[s
             continue
         status = "available" if path.exists() or label == "review_result" else "missing"
         links.append({"label": label, "path": str(path), "status": status})
+    for index, path in enumerate(_ordered_unique(internal_report_paths or []), start=1):
+        try:
+            status = "available" if Path(path).exists() else "missing"
+        except (OSError, ValueError):
+            status = "missing"
+        links.append({"label": f"internal_report_{index}", "path": path, "status": status})
     return links
 
 
@@ -1328,7 +1375,7 @@ def _compact_review_evidence(
     impact = artifacts.get("impact") if isinstance(artifacts.get("impact"), dict) else {}
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
     apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
-    return {
+    evidence = {
         "artifact_paths": _artifact_path_pointers(artifact_rows),
         "audit_summary": {
             "validate": {"type": validate.get("type"), "message": validate.get("message")},
@@ -1344,6 +1391,9 @@ def _compact_review_evidence(
             "review": _compact_review_audit(result),
         },
     }
+    for key in ("run_id", "parent_run_id", "is_final", "report_scope", "published_to"):
+        evidence[key] = result.get(key)
+    return evidence
 
 
 def _user_decision(result: Dict[str, Any], artifacts: Dict[str, Any]) -> UserDecisionEvent:
@@ -1367,30 +1417,64 @@ def _user_decision(result: Dict[str, Any], artifacts: Dict[str, Any]) -> UserDec
 
 
 class _ReportPayload:
-    def __init__(self, run: CommandRun, focused_view: Dict[str, Any]):
+    def __init__(self, run: CommandRun, focused_view: Dict[str, Any], report_dir: Optional[Path] = None):
         self.run = run
         self.focused_view = focused_view
+        self.report_dir = report_dir
 
     def to_dict(self) -> Dict[str, Any]:
         data = self.run.to_dict()
         if self.focused_view:
             data["focused_view"] = self.focused_view
+        if self.report_dir is not None:
+            data["report_dir"] = str(self.report_dir)
         return data
 
 
-def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path: Optional[Path]) -> Dict[str, Any]:
+def _publish_review_report(
+    result: Dict[str, Any],
+    plan_path: Path,
+    impact_path: Optional[Path],
+    *,
+    report_scope: str = "final",
+    report_dir: Optional[Path] = None,
+    parent_run_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    report_scope = _normalize_report_scope(report_scope)
+    previous_result = _load_existing_review_result()
+    internal_report_paths = _existing_internal_report_paths(previous_result)
+    run_id = str(result.get("run_id") or uuid.uuid4().hex)
+    if parent_run_id is None:
+        parent_run_id = result.get("parent_run_id")
+
+    result["run_id"] = run_id
+    result["parent_run_id"] = parent_run_id
+    result["is_final"] = report_scope == "final"
+    result["report_scope"] = report_scope
+    result["internal_report_paths"] = internal_report_paths
+
+    if report_scope == "none":
+        result["published_to"] = None
+        result.pop("report_path", None)
+        _write_review_result(result)
+        return result
+
+    target_report_dir = _report_target_dir(report_scope, report_dir)
+    result["published_to"] = str(_expected_report_path(target_report_dir, run_id))
     _write_review_result(result)
+
     artifacts = _load_review_artifacts(plan_path, impact_path)
     candidates = _selected_candidate_rows(artifacts)
     code_deltas = _code_delta_rows(artifacts)
     focused_view = _feature_evidence_groups(artifacts, candidates, code_deltas, result)
-    artifact_rows = _artifact_links(plan_path, impact_path)
+    artifact_rows = _artifact_links(plan_path, impact_path, internal_report_paths)
     evidence = _compact_review_evidence(artifacts, artifact_rows, result)
     try:
         report_run = CommandRun(
             command="rpg_edit",
             title="CoderMind rpg_edit Explain View",
             status=str(result.get("type", "review")),
+            timestamp=run_id,
             summary=_review_summary_cards(result, artifacts, focused_view),
             steps=[
                 StepEvent(name=row.get("name", "stage"), status=row.get("status"), reason=row.get("reason", ""))
@@ -1440,8 +1524,11 @@ def _publish_review_report(result: Dict[str, Any], plan_path: Path, impact_path:
             user_decisions=[_user_decision(result, artifacts)],
             evidence=evidence,
         )
-        report_path = write_command_report(_ReportPayload(report_run, focused_view))
+        report_path = write_command_report(_ReportPayload(report_run, focused_view, target_report_dir))
         result["report_path"] = str(report_path)
+        result["published_to"] = str(report_path)
+        if report_scope == "internal":
+            result["internal_report_paths"] = _ordered_unique(internal_report_paths + [str(report_path)])
     except Exception as exc:
         result["report_error"] = str(exc)
     _write_review_result(result)
@@ -1796,6 +1883,9 @@ def impact_review(
     repo_path: Path,
     max_iterations: int = 3,
     timeout: int = 600,
+    report_scope: str = "final",
+    report_dir: Optional[Path] = None,
+    parent_run_id: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Run impact-scoped review with iterative repair."""
     from run_batch import dispatch_sub_agent
@@ -1956,7 +2046,14 @@ def impact_review(
                 all_suggestions.append(s)
     if all_suggestions:
         results["suggestions"] = all_suggestions
-    return _publish_review_report(results, plan_path, impact_path)
+    return _publish_review_report(
+        results,
+        plan_path,
+        impact_path,
+        report_scope=report_scope,
+        report_dir=report_dir,
+        parent_run_id=parent_run_id,
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -1978,9 +2075,18 @@ def main():
                         help="Maximum review+repair iterations (default: 3)")
     parser.add_argument("--timeout", type=int, default=600,
                         help="Sub-agent timeout per iteration in seconds (default: 600)")
+    parser.add_argument("--report-scope", choices=sorted(_REPORT_SCOPES), default="final",
+                        help="HTML report publication scope (default: %(default)s)")
+    parser.add_argument("--no-report", action="store_true",
+                        help="Persist review JSON without writing an HTML report")
+    parser.add_argument("--report-dir", type=Path, default=None,
+                        help="Base report directory (default: .cmind/reports)")
+    parser.add_argument("--parent-run-id", default=None,
+                        help="Parent command run ID to record in report evidence")
     parser.add_argument("--json", action="store_true",
                         help="Output as JSON")
     args = parser.parse_args()
+    report_scope = "none" if args.no_report else args.report_scope
 
     logging.basicConfig(
         level=logging.INFO,
@@ -1993,7 +2099,14 @@ def main():
 
     if not args.plan.exists():
         result = {"type": "error", "message": f"Plan not found: {args.plan}"}
-        result = _publish_review_report(result, args.plan, args.impact)
+        result = _publish_review_report(
+            result,
+            args.plan,
+            args.impact,
+            report_scope=report_scope,
+            report_dir=args.report_dir,
+            parent_run_id=args.parent_run_id,
+        )
         print(json.dumps(result) if args.json else f"Error: {result['message']}")
         return 1
 
@@ -2015,7 +2128,14 @@ def main():
                           f"(callers={total_callers}, files={affected_files}). "
                           f"Agent self-review is sufficient.",
             }
-            result = _publish_review_report(result, args.plan, args.impact)
+            result = _publish_review_report(
+                result,
+                args.plan,
+                args.impact,
+                report_scope=report_scope,
+                report_dir=args.report_dir,
+                parent_run_id=args.parent_run_id,
+            )
             print(json.dumps(result, indent=2) if args.json else
                   f"Skipped: {result['reason']}\nReport: {result.get('report_path', '')}")
             return 0
@@ -2026,6 +2146,9 @@ def main():
         repo_path=repo_path,
         max_iterations=args.max_iterations,
         timeout=args.timeout,
+        report_scope=report_scope,
+        report_dir=args.report_dir,
+        parent_run_id=args.parent_run_id,
     )
 
     if args.json:
diff --git a/CoderMind/templates/commands/rpg_edit.md b/CoderMind/templates/commands/rpg_edit.md
index 03c8e4c..7fbc05b 100644
--- a/CoderMind/templates/commands/rpg_edit.md
+++ b/CoderMind/templates/commands/rpg_edit.md
@@ -333,9 +333,14 @@ cmind script smoke_test.py --json
 1. **Impact review** — run targeted tests and verify affected functionality:
 
 ```bash
-cmind script rpg_edit/review.py --json
+cmind script rpg_edit/review.py --report-scope final --json
 ```
 
+The outer `rpg_edit` flow owns the sole user-visible final report;
+intermediate or nested review runs should use `--report-scope internal`
+or `--no-report` so their artifacts can be linked without publishing a
+second final report.
+
 The review script reads the plan and impact JSON from their default
 home-dir locations and automatically:
 
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 8c902e2..82018d9 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -351,7 +351,7 @@ def fake_write_command_report(run):
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
 
-    result = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path)
+    result = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path, report_scope="final")
 
     assert result["report_path"] == str(report_path)
     persisted = json.loads(review_path.read_text(encoding="utf-8"))
@@ -535,6 +535,129 @@ def fake_write_command_report(run):
 
     monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
 
-    result = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path)
+    result = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path, report_scope="final")
 
     assert result["report_path"] == str(report_path)
+
+
+def _patch_minimal_review_report(review, tmp_path: Path, monkeypatch) -> tuple[Path, None, Path]:
+    plan_path = tmp_path / "plan.json"
+    review_path = tmp_path / "review.json"
+    plan_path.write_text(json.dumps({"affected_nodes": [], "code_changes": []}), encoding="utf-8")
+
+    monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
+    monkeypatch.setattr(review, "RPG_EDIT_VALIDATE_FILE", tmp_path / "validate.json")
+    monkeypatch.setattr(review, "RPG_EDIT_LOCATE_FILE", tmp_path / "locate.json")
+    monkeypatch.setattr(review, "RPG_EDIT_CODE_RESULT_FILE", tmp_path / "code.json")
+    monkeypatch.setattr(review, "RPG_EDIT_APPLY_RESULT_FILE", tmp_path / "apply.json")
+    monkeypatch.setattr(review, "REPORTS_DIR", tmp_path / "reports")
+    monkeypatch.setattr(review, "_load_review_artifacts", lambda plan, impact: {"plan": {"affected_nodes": [], "code_changes": []}})
+    monkeypatch.setattr(review, "_selected_candidate_rows", lambda artifacts: [])
+    monkeypatch.setattr(review, "_code_delta_rows", lambda artifacts: [])
+    monkeypatch.setattr(review, "_feature_evidence_groups", lambda artifacts, candidates, code_deltas, result: {})
+    monkeypatch.setattr(review, "_review_summary_cards", lambda result, artifacts, focused_view: [])
+    monkeypatch.setattr(review, "_review_timeline", lambda result, artifacts: [])
+    monkeypatch.setattr(review, "_retrieval_rows", lambda artifacts, candidates: [])
+    monkeypatch.setattr(review, "_review_verification", lambda result, artifacts: [])
+    monkeypatch.setattr(review, "_user_decision", lambda result, artifacts: review.UserDecisionEvent(decision="apply"))
+    return plan_path, None, review_path
+
+
+def test_review_report_scope_none_persists_without_html(tmp_path: Path, monkeypatch) -> None:
+    review = _load_script("rpg_edit_review_scope_none_test", _SCRIPTS / "rpg_edit" / "review.py")
+    plan_path, impact_path, review_path = _patch_minimal_review_report(review, tmp_path, monkeypatch)
+
+    def fake_write_command_report(run):
+        raise AssertionError("write_command_report should not be called for report_scope=none")
+
+    monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
+
+    result = review._publish_review_report(
+        {"type": "skipped", "success": True},
+        plan_path,
+        impact_path,
+        report_scope="none",
+        parent_run_id="parent-1",
+    )
+
+    assert "report_path" not in result
+    assert result["published_to"] is None
+    assert result["report_scope"] == "none"
+    assert result["is_final"] is False
+    assert result["parent_run_id"] == "parent-1"
+    persisted = json.loads(review_path.read_text(encoding="utf-8"))
+    assert persisted["report_scope"] == "none"
+    assert persisted["published_to"] is None
+    assert "report_path" not in persisted
+
+
+def test_review_report_scope_internal_writes_under_internal_report_dir(tmp_path: Path, monkeypatch) -> None:
+    review = _load_script("rpg_edit_review_scope_internal_test", _SCRIPTS / "rpg_edit" / "review.py")
+    plan_path, impact_path, review_path = _patch_minimal_review_report(review, tmp_path, monkeypatch)
+    captured: dict[str, dict] = {}
+
+    def fake_write_command_report(run):
+        data = run.to_dict()
+        captured["data"] = data
+        target_dir = Path(data["report_dir"])
+        assert target_dir == tmp_path / "reports" / "internal"
+        report_path = target_dir / "internal-report.html"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        report_path.write_text("<html></html>", encoding="utf-8")
+        return report_path
+
+    monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
+
+    result = review._publish_review_report(
+        {"type": "skipped", "success": True},
+        plan_path,
+        impact_path,
+        report_scope="internal",
+        parent_run_id="parent-2",
+    )
+
+    assert result["report_path"] == str(tmp_path / "reports" / "internal" / "internal-report.html")
+    assert result["internal_report_paths"] == [result["report_path"]]
+    assert result["report_scope"] == "internal"
+    assert result["is_final"] is False
+    evidence = captured["data"]["evidence"]
+    assert evidence["report_scope"] == "internal"
+    assert evidence["is_final"] is False
+    assert evidence["parent_run_id"] == "parent-2"
+    assert evidence["published_to"].startswith(str(tmp_path / "reports" / "internal" / "cmind_run_rpg_edit_"))
+    persisted = json.loads(review_path.read_text(encoding="utf-8"))
+    assert persisted["internal_report_paths"] == [result["report_path"]]
+
+
+def test_review_final_report_preserves_internal_report_artifacts(tmp_path: Path, monkeypatch) -> None:
+    review = _load_script("rpg_edit_review_scope_final_artifacts_test", _SCRIPTS / "rpg_edit" / "review.py")
+    plan_path, impact_path, _review_path = _patch_minimal_review_report(review, tmp_path, monkeypatch)
+    writes: list[dict] = []
+
+    def fake_write_command_report(run):
+        data = run.to_dict()
+        writes.append(data)
+        target_dir = Path(data["report_dir"])
+        target_dir.mkdir(parents=True, exist_ok=True)
+        report_path = target_dir / f"{data['evidence']['report_scope']}-{len(writes)}.html"
+        report_path.write_text("<html></html>", encoding="utf-8")
+        return report_path
+
+    monkeypatch.setattr(review, "write_command_report", fake_write_command_report)
+
+    first = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path, report_scope="internal")
+    second = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path, report_scope="internal")
+    final = review._publish_review_report({"type": "skipped", "success": True}, plan_path, impact_path, report_scope="final")
+
+    internal_paths = [first["report_path"], second["report_path"]]
+    assert final["internal_report_paths"] == internal_paths
+    final_data = writes[-1]
+    artifact_paths = {item["label"]: item["path"] for item in final_data["artifacts"]}
+    assert artifact_paths["internal_report_1"] == internal_paths[0]
+    assert artifact_paths["internal_report_2"] == internal_paths[1]
+    evidence_paths = {item["label"]: item["path"] for item in final_data["evidence"]["artifact_paths"]}
+    assert evidence_paths["internal_report_1"] == internal_paths[0]
+    assert evidence_paths["internal_report_2"] == internal_paths[1]
+    assert final_data["report_dir"] == str(tmp_path / "reports")
+    assert final_data["evidence"]["report_scope"] == "final"
+    assert final_data["evidence"]["is_final"] is True

From 88186db444e63104de4aed520e5d18ef6a103dea Mon Sep 17 00:00:00 2001
From: Yasen Hu <74404492+HuYaSen@users.noreply.github.com>
Date: Mon, 6 Jul 2026 16:40:51 +0800
Subject: [PATCH 22/56] fix(update_graphs): use actual result status for
 update_rpg report

---
 CoderMind/scripts/update_graphs.py      | 2 +-
 CoderMind/tests/test_encode_commands.py | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index d4b2042..825e955 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -171,7 +171,7 @@ def _attach_update_report(result: dict) -> dict:
         report_path = write_command_report(CommandRun(
             command="update_rpg",
             title="CoderMind update_rpg Explain View",
-            status=result.get("mode") or result.get("status"),
+            status=result.get("status", result.get("mode")),
             summary=[
                 {"label": "mode", "value": result.get("mode", "")},
                 {
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 3af2f6d..391cce0 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -439,6 +439,7 @@ def fake_write_command_report(run):
     assert cards["RPG nodes"] == "4504 (delta: +2)"
     assert cards["dep graph"] == "nodes=2708 (delta: +46), edges=5498 (delta: +103)"
     assert artifacts["rpg_json"] == "/tmp/rpg.json"
+    assert captured["status"] == "success"
     assert captured["steps"][0]["reason"] == "2 changed files"
     assert captured["steps"][1]["reason"] == "3 semantic files, modified=3"
 

From 905d87b42ae07de6e78ecf6efcaf00483e53cd8e Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Mon, 6 Jul 2026 09:00:29 +0000
Subject: [PATCH 23/56] rpg_edit: At _build_nodes_view (line 435), add focused
 graph hierarchy

---
 CoderMind/scripts/common/assets/d3.v7.min.js |   2 +
 CoderMind/scripts/common/run_report.py       | 336 ++++++++++++++++++-
 CoderMind/scripts/rpg_edit/review.py         | 242 ++++++++++++-
 CoderMind/tests/test_rpg_edit_run_report.py  |  27 ++
 CoderMind/tests/test_run_report.py           |  97 +++++-
 5 files changed, 678 insertions(+), 26 deletions(-)
 create mode 100644 CoderMind/scripts/common/assets/d3.v7.min.js

diff --git a/CoderMind/scripts/common/assets/d3.v7.min.js b/CoderMind/scripts/common/assets/d3.v7.min.js
new file mode 100644
index 0000000..33bb880
--- /dev/null
+++ b/CoderMind/scripts/common/assets/d3.v7.min.js
@@ -0,0 +1,2 @@
+// https://d3js.org v7.9.0 Copyright 2010-2023 Mike Bostock
+!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).d3=t.d3||{})}(this,(function(t){"use strict";function n(t,n){return null==t||null==n?NaN:t<n?-1:t>n?1:t>=n?0:NaN}function e(t,n){return null==t||null==n?NaN:n<t?-1:n>t?1:n>=t?0:NaN}function r(t){let r,o,a;function u(t,n,e=0,i=t.length){if(e<i){if(0!==r(n,n))return i;do{const r=e+i>>>1;o(t[r],n)<0?e=r+1:i=r}while(e<i)}return e}return 2!==t.length?(r=n,o=(e,r)=>n(t(e),r),a=(n,e)=>t(n)-e):(r=t===n||t===e?t:i,o=t,a=t),{left:u,center:function(t,n,e=0,r=t.length){const i=u(t,n,e,r-1);return i>e&&a(t[i-1],n)>-a(t[i],n)?i-1:i},right:function(t,n,e=0,i=t.length){if(e<i){if(0!==r(n,n))return i;do{const r=e+i>>>1;o(t[r],n)<=0?e=r+1:i=r}while(e<i)}return e}}}function i(){return 0}function o(t){return null===t?NaN:+t}const a=r(n),u=a.right,c=a.left,f=r(o).center;var s=u;const l=d(y),h=d((function(t){const n=y(t);return(t,e,r,i,o)=>{n(t,e,(r<<=2)+0,(i<<=2)+0,o<<=2),n(t,e,r+1,i+1,o),n(t,e,r+2,i+2,o),n(t,e,r+3,i+3,o)}}));function d(t){return function(n,e,r=e){if(!((e=+e)>=0))throw new RangeError("invalid rx");if(!((r=+r)>=0))throw new RangeError("invalid ry");let{data:i,width:o,height:a}=n;if(!((o=Math.floor(o))>=0))throw new RangeError("invalid width");if(!((a=Math.floor(void 0!==a?a:i.length/o))>=0))throw new RangeError("invalid height");if(!o||!a||!e&&!r)return n;const u=e&&t(e),c=r&&t(r),f=i.slice();return u&&c?(p(u,f,i,o,a),p(u,i,f,o,a),p(u,f,i,o,a),g(c,i,f,o,a),g(c,f,i,o,a),g(c,i,f,o,a)):u?(p(u,i,f,o,a),p(u,f,i,o,a),p(u,i,f,o,a)):c&&(g(c,i,f,o,a),g(c,f,i,o,a),g(c,i,f,o,a)),n}}function p(t,n,e,r,i){for(let o=0,a=r*i;o<a;)t(n,e,o,o+=r,1)}function g(t,n,e,r,i){for(let o=0,a=r*i;o<r;++o)t(n,e,o,o+a,r)}function y(t){const n=Math.floor(t);if(n===t)return function(t){const n=2*t+1;return(e,r,i,o,a)=>{if(!((o-=a)>=i))return;let u=t*r[i];const c=a*t;for(let t=i,n=i+c;t<n;t+=a)u+=r[Math.min(o,t)];for(let t=i,f=o;t<=f;t+=a)u+=r[Math.min(o,t+c)],e[t]=u/n,u-=r[Math.max(i,t-c)]}}(t);const e=t-n,r=2*t+1;return(t,i,o,a,u)=>{if(!((a-=u)>=o))return;let c=n*i[o];const f=u*n,s=f+u;for(let t=o,n=o+f;t<n;t+=u)c+=i[Math.min(a,t)];for(let n=o,l=a;n<=l;n+=u)c+=i[Math.min(a,n+f)],t[n]=(c+e*(i[Math.max(o,n-s)]+i[Math.min(a,n+s)]))/r,c-=i[Math.max(o,n-f)]}}function v(t,n){let e=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&++e;else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(i=+i)>=i&&++e}return e}function _(t){return 0|t.length}function b(t){return!(t>0)}function m(t){return"object"!=typeof t||"length"in t?t:Array.from(t)}function x(t,n){let e,r=0,i=0,o=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(e=n-i,i+=e/++r,o+=e*(n-i));else{let a=-1;for(let u of t)null!=(u=n(u,++a,t))&&(u=+u)>=u&&(e=u-i,i+=e/++r,o+=e*(u-i))}if(r>1)return o/(r-1)}function w(t,n){const e=x(t,n);return e?Math.sqrt(e):e}function M(t,n){let e,r;if(void 0===n)for(const n of t)null!=n&&(void 0===e?n>=n&&(e=r=n):(e>n&&(e=n),r<n&&(r=n)));else{let i=-1;for(let o of t)null!=(o=n(o,++i,t))&&(void 0===e?o>=o&&(e=r=o):(e>o&&(e=o),r<o&&(r=o)))}return[e,r]}class T{constructor(){this._partials=new Float64Array(32),this._n=0}add(t){const n=this._partials;let e=0;for(let r=0;r<this._n&&r<32;r++){const i=n[r],o=t+i,a=Math.abs(t)<Math.abs(i)?t-(o-i):i-(o-t);a&&(n[e++]=a),t=o}return n[e]=t,this._n=e+1,this}valueOf(){const t=this._partials;let n,e,r,i=this._n,o=0;if(i>0){for(o=t[--i];i>0&&(n=o,e=t[--i],o=n+e,r=e-(o-n),!r););i>0&&(r<0&&t[i-1]<0||r>0&&t[i-1]>0)&&(e=2*r,n=o+e,e==n-o&&(o=n))}return o}}class InternMap extends Map{constructor(t,n=N){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),null!=t)for(const[n,e]of t)this.set(n,e)}get(t){return super.get(A(this,t))}has(t){return super.has(A(this,t))}set(t,n){return super.set(S(this,t),n)}delete(t){return super.delete(E(this,t))}}class InternSet extends Set{constructor(t,n=N){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),null!=t)for(const n of t)this.add(n)}has(t){return super.has(A(this,t))}add(t){return super.add(S(this,t))}delete(t){return super.delete(E(this,t))}}function A({_intern:t,_key:n},e){const r=n(e);return t.has(r)?t.get(r):e}function S({_intern:t,_key:n},e){const r=n(e);return t.has(r)?t.get(r):(t.set(r,e),e)}function E({_intern:t,_key:n},e){const r=n(e);return t.has(r)&&(e=t.get(r),t.delete(r)),e}function N(t){return null!==t&&"object"==typeof t?t.valueOf():t}function k(t){return t}function C(t,...n){return F(t,k,k,n)}function P(t,...n){return F(t,Array.from,k,n)}function z(t,n){for(let e=1,r=n.length;e<r;++e)t=t.flatMap((t=>t.pop().map((([n,e])=>[...t,n,e]))));return t}function $(t,n,...e){return F(t,k,n,e)}function D(t,n,...e){return F(t,Array.from,n,e)}function R(t){if(1!==t.length)throw new Error("duplicate key");return t[0]}function F(t,n,e,r){return function t(i,o){if(o>=r.length)return e(i);const a=new InternMap,u=r[o++];let c=-1;for(const t of i){const n=u(t,++c,i),e=a.get(n);e?e.push(t):a.set(n,[t])}for(const[n,e]of a)a.set(n,t(e,o));return n(a)}(t,0)}function q(t,n){return Array.from(n,(n=>t[n]))}function U(t,...n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");t=Array.from(t);let[e]=n;if(e&&2!==e.length||n.length>1){const r=Uint32Array.from(t,((t,n)=>n));return n.length>1?(n=n.map((n=>t.map(n))),r.sort(((t,e)=>{for(const r of n){const n=O(r[t],r[e]);if(n)return n}}))):(e=t.map(e),r.sort(((t,n)=>O(e[t],e[n])))),q(t,r)}return t.sort(I(e))}function I(t=n){if(t===n)return O;if("function"!=typeof t)throw new TypeError("compare is not a function");return(n,e)=>{const r=t(n,e);return r||0===r?r:(0===t(e,e))-(0===t(n,n))}}function O(t,n){return(null==t||!(t>=t))-(null==n||!(n>=n))||(t<n?-1:t>n?1:0)}var B=Array.prototype.slice;function Y(t){return()=>t}const L=Math.sqrt(50),j=Math.sqrt(10),H=Math.sqrt(2);function X(t,n,e){const r=(n-t)/Math.max(0,e),i=Math.floor(Math.log10(r)),o=r/Math.pow(10,i),a=o>=L?10:o>=j?5:o>=H?2:1;let u,c,f;return i<0?(f=Math.pow(10,-i)/a,u=Math.round(t*f),c=Math.round(n*f),u/f<t&&++u,c/f>n&&--c,f=-f):(f=Math.pow(10,i)*a,u=Math.round(t/f),c=Math.round(n/f),u*f<t&&++u,c*f>n&&--c),c<u&&.5<=e&&e<2?X(t,n,2*e):[u,c,f]}function G(t,n,e){if(!((e=+e)>0))return[];if((t=+t)===(n=+n))return[t];const r=n<t,[i,o,a]=r?X(n,t,e):X(t,n,e);if(!(o>=i))return[];const u=o-i+1,c=new Array(u);if(r)if(a<0)for(let t=0;t<u;++t)c[t]=(o-t)/-a;else for(let t=0;t<u;++t)c[t]=(o-t)*a;else if(a<0)for(let t=0;t<u;++t)c[t]=(i+t)/-a;else for(let t=0;t<u;++t)c[t]=(i+t)*a;return c}function V(t,n,e){return X(t=+t,n=+n,e=+e)[2]}function W(t,n,e){e=+e;const r=(n=+n)<(t=+t),i=r?V(n,t,e):V(t,n,e);return(r?-1:1)*(i<0?1/-i:i)}function Z(t,n,e){let r;for(;;){const i=V(t,n,e);if(i===r||0===i||!isFinite(i))return[t,n];i>0?(t=Math.floor(t/i)*i,n=Math.ceil(n/i)*i):i<0&&(t=Math.ceil(t*i)/i,n=Math.floor(n*i)/i),r=i}}function K(t){return Math.max(1,Math.ceil(Math.log(v(t))/Math.LN2)+1)}function Q(){var t=k,n=M,e=K;function r(r){Array.isArray(r)||(r=Array.from(r));var i,o,a,u=r.length,c=new Array(u);for(i=0;i<u;++i)c[i]=t(r[i],i,r);var f=n(c),l=f[0],h=f[1],d=e(c,l,h);if(!Array.isArray(d)){const t=h,e=+d;if(n===M&&([l,h]=Z(l,h,e)),(d=G(l,h,e))[0]<=l&&(a=V(l,h,e)),d[d.length-1]>=h)if(t>=h&&n===M){const t=V(l,h,e);isFinite(t)&&(t>0?h=(Math.floor(h/t)+1)*t:t<0&&(h=(Math.ceil(h*-t)+1)/-t))}else d.pop()}for(var p=d.length,g=0,y=p;d[g]<=l;)++g;for(;d[y-1]>h;)--y;(g||y<p)&&(d=d.slice(g,y),p=y-g);var v,_=new Array(p+1);for(i=0;i<=p;++i)(v=_[i]=[]).x0=i>0?d[i-1]:l,v.x1=i<p?d[i]:h;if(isFinite(a)){if(a>0)for(i=0;i<u;++i)null!=(o=c[i])&&l<=o&&o<=h&&_[Math.min(p,Math.floor((o-l)/a))].push(r[i]);else if(a<0)for(i=0;i<u;++i)if(null!=(o=c[i])&&l<=o&&o<=h){const t=Math.floor((l-o)*a);_[Math.min(p,t+(d[t]<=o))].push(r[i])}}else for(i=0;i<u;++i)null!=(o=c[i])&&l<=o&&o<=h&&_[s(d,o,0,p)].push(r[i]);return _}return r.value=function(n){return arguments.length?(t="function"==typeof n?n:Y(n),r):t},r.domain=function(t){return arguments.length?(n="function"==typeof t?t:Y([t[0],t[1]]),r):n},r.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Y(Array.isArray(t)?B.call(t):t),r):e},r}function J(t,n){let e;if(void 0===n)for(const n of t)null!=n&&(e<n||void 0===e&&n>=n)&&(e=n);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(e<i||void 0===e&&i>=i)&&(e=i)}return e}function tt(t,n){let e,r=-1,i=-1;if(void 0===n)for(const n of t)++i,null!=n&&(e<n||void 0===e&&n>=n)&&(e=n,r=i);else for(let o of t)null!=(o=n(o,++i,t))&&(e<o||void 0===e&&o>=o)&&(e=o,r=i);return r}function nt(t,n){let e;if(void 0===n)for(const n of t)null!=n&&(e>n||void 0===e&&n>=n)&&(e=n);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(e>i||void 0===e&&i>=i)&&(e=i)}return e}function et(t,n){let e,r=-1,i=-1;if(void 0===n)for(const n of t)++i,null!=n&&(e>n||void 0===e&&n>=n)&&(e=n,r=i);else for(let o of t)null!=(o=n(o,++i,t))&&(e>o||void 0===e&&o>=o)&&(e=o,r=i);return r}function rt(t,n,e=0,r=1/0,i){if(n=Math.floor(n),e=Math.floor(Math.max(0,e)),r=Math.floor(Math.min(t.length-1,r)),!(e<=n&&n<=r))return t;for(i=void 0===i?O:I(i);r>e;){if(r-e>600){const o=r-e+1,a=n-e+1,u=Math.log(o),c=.5*Math.exp(2*u/3),f=.5*Math.sqrt(u*c*(o-c)/o)*(a-o/2<0?-1:1);rt(t,n,Math.max(e,Math.floor(n-a*c/o+f)),Math.min(r,Math.floor(n+(o-a)*c/o+f)),i)}const o=t[n];let a=e,u=r;for(it(t,e,n),i(t[r],o)>0&&it(t,e,r);a<u;){for(it(t,a,u),++a,--u;i(t[a],o)<0;)++a;for(;i(t[u],o)>0;)--u}0===i(t[e],o)?it(t,e,u):(++u,it(t,u,r)),u<=n&&(e=u+1),n<=u&&(r=u-1)}return t}function it(t,n,e){const r=t[n];t[n]=t[e],t[e]=r}function ot(t,e=n){let r,i=!1;if(1===e.length){let o;for(const a of t){const t=e(a);(i?n(t,o)>0:0===n(t,t))&&(r=a,o=t,i=!0)}}else for(const n of t)(i?e(n,r)>0:0===e(n,n))&&(r=n,i=!0);return r}function at(t,n,e){if(t=Float64Array.from(function*(t,n){if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(yield n);else{let e=-1;for(let r of t)null!=(r=n(r,++e,t))&&(r=+r)>=r&&(yield r)}}(t,e)),(r=t.length)&&!isNaN(n=+n)){if(n<=0||r<2)return nt(t);if(n>=1)return J(t);var r,i=(r-1)*n,o=Math.floor(i),a=J(rt(t,o).subarray(0,o+1));return a+(nt(t.subarray(o+1))-a)*(i-o)}}function ut(t,n,e=o){if((r=t.length)&&!isNaN(n=+n)){if(n<=0||r<2)return+e(t[0],0,t);if(n>=1)return+e(t[r-1],r-1,t);var r,i=(r-1)*n,a=Math.floor(i),u=+e(t[a],a,t);return u+(+e(t[a+1],a+1,t)-u)*(i-a)}}function ct(t,n,e=o){if(!isNaN(n=+n)){if(r=Float64Array.from(t,((n,r)=>o(e(t[r],r,t)))),n<=0)return et(r);if(n>=1)return tt(r);var r,i=Uint32Array.from(t,((t,n)=>n)),a=r.length-1,u=Math.floor(a*n);return rt(i,u,0,a,((t,n)=>O(r[t],r[n]))),(u=ot(i.subarray(0,u+1),(t=>r[t])))>=0?u:-1}}function ft(t){return Array.from(function*(t){for(const n of t)yield*n}(t))}function st(t,n){return[t,n]}function lt(t,n,e){t=+t,n=+n,e=(i=arguments.length)<2?(n=t,t=0,1):i<3?1:+e;for(var r=-1,i=0|Math.max(0,Math.ceil((n-t)/e)),o=new Array(i);++r<i;)o[r]=t+r*e;return o}function ht(t,e=n){if(1===e.length)return et(t,e);let r,i=-1,o=-1;for(const n of t)++o,(i<0?0===e(n,n):e(n,r)<0)&&(r=n,i=o);return i}var dt=pt(Math.random);function pt(t){return function(n,e=0,r=n.length){let i=r-(e=+e);for(;i;){const r=t()*i--|0,o=n[i+e];n[i+e]=n[r+e],n[r+e]=o}return n}}function gt(t){if(!(i=t.length))return[];for(var n=-1,e=nt(t,yt),r=new Array(e);++n<e;)for(var i,o=-1,a=r[n]=new Array(i);++o<i;)a[o]=t[o][n];return r}function yt(t){return t.length}function vt(t){return t instanceof InternSet?t:new InternSet(t)}function _t(t,n){const e=t[Symbol.iterator](),r=new Set;for(const t of n){const n=bt(t);if(r.has(n))continue;let i,o;for(;({value:i,done:o}=e.next());){if(o)return!1;const t=bt(i);if(r.add(t),Object.is(n,t))break}}return!0}function bt(t){return null!==t&&"object"==typeof t?t.valueOf():t}function mt(t){return t}var xt=1,wt=2,Mt=3,Tt=4,At=1e-6;function St(t){return"translate("+t+",0)"}function Et(t){return"translate(0,"+t+")"}function Nt(t){return n=>+t(n)}function kt(t,n){return n=Math.max(0,t.bandwidth()-2*n)/2,t.round()&&(n=Math.round(n)),e=>+t(e)+n}function Ct(){return!this.__axis}function Pt(t,n){var e=[],r=null,i=null,o=6,a=6,u=3,c="undefined"!=typeof window&&window.devicePixelRatio>1?0:.5,f=t===xt||t===Tt?-1:1,s=t===Tt||t===wt?"x":"y",l=t===xt||t===Mt?St:Et;function h(h){var d=null==r?n.ticks?n.ticks.apply(n,e):n.domain():r,p=null==i?n.tickFormat?n.tickFormat.apply(n,e):mt:i,g=Math.max(o,0)+u,y=n.range(),v=+y[0]+c,_=+y[y.length-1]+c,b=(n.bandwidth?kt:Nt)(n.copy(),c),m=h.selection?h.selection():h,x=m.selectAll(".domain").data([null]),w=m.selectAll(".tick").data(d,n).order(),M=w.exit(),T=w.enter().append("g").attr("class","tick"),A=w.select("line"),S=w.select("text");x=x.merge(x.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),w=w.merge(T),A=A.merge(T.append("line").attr("stroke","currentColor").attr(s+"2",f*o)),S=S.merge(T.append("text").attr("fill","currentColor").attr(s,f*g).attr("dy",t===xt?"0em":t===Mt?"0.71em":"0.32em")),h!==m&&(x=x.transition(h),w=w.transition(h),A=A.transition(h),S=S.transition(h),M=M.transition(h).attr("opacity",At).attr("transform",(function(t){return isFinite(t=b(t))?l(t+c):this.getAttribute("transform")})),T.attr("opacity",At).attr("transform",(function(t){var n=this.parentNode.__axis;return l((n&&isFinite(n=n(t))?n:b(t))+c)}))),M.remove(),x.attr("d",t===Tt||t===wt?a?"M"+f*a+","+v+"H"+c+"V"+_+"H"+f*a:"M"+c+","+v+"V"+_:a?"M"+v+","+f*a+"V"+c+"H"+_+"V"+f*a:"M"+v+","+c+"H"+_),w.attr("opacity",1).attr("transform",(function(t){return l(b(t)+c)})),A.attr(s+"2",f*o),S.attr(s,f*g).text(p),m.filter(Ct).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",t===wt?"start":t===Tt?"end":"middle"),m.each((function(){this.__axis=b}))}return h.scale=function(t){return arguments.length?(n=t,h):n},h.ticks=function(){return e=Array.from(arguments),h},h.tickArguments=function(t){return arguments.length?(e=null==t?[]:Array.from(t),h):e.slice()},h.tickValues=function(t){return arguments.length?(r=null==t?null:Array.from(t),h):r&&r.slice()},h.tickFormat=function(t){return arguments.length?(i=t,h):i},h.tickSize=function(t){return arguments.length?(o=a=+t,h):o},h.tickSizeInner=function(t){return arguments.length?(o=+t,h):o},h.tickSizeOuter=function(t){return arguments.length?(a=+t,h):a},h.tickPadding=function(t){return arguments.length?(u=+t,h):u},h.offset=function(t){return arguments.length?(c=+t,h):c},h}var zt={value:()=>{}};function $t(){for(var t,n=0,e=arguments.length,r={};n<e;++n){if(!(t=arguments[n]+"")||t in r||/[\s.]/.test(t))throw new Error("illegal type: "+t);r[t]=[]}return new Dt(r)}function Dt(t){this._=t}function Rt(t,n){for(var e,r=0,i=t.length;r<i;++r)if((e=t[r]).name===n)return e.value}function Ft(t,n,e){for(var r=0,i=t.length;r<i;++r)if(t[r].name===n){t[r]=zt,t=t.slice(0,r).concat(t.slice(r+1));break}return null!=e&&t.push({name:n,value:e}),t}Dt.prototype=$t.prototype={constructor:Dt,on:function(t,n){var e,r,i=this._,o=(r=i,(t+"").trim().split(/^|\s+/).map((function(t){var n="",e=t.indexOf(".");if(e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),t&&!r.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))),a=-1,u=o.length;if(!(arguments.length<2)){if(null!=n&&"function"!=typeof n)throw new Error("invalid callback: "+n);for(;++a<u;)if(e=(t=o[a]).type)i[e]=Ft(i[e],t.name,n);else if(null==n)for(e in i)i[e]=Ft(i[e],t.name,null);return this}for(;++a<u;)if((e=(t=o[a]).type)&&(e=Rt(i[e],t.name)))return e},copy:function(){var t={},n=this._;for(var e in n)t[e]=n[e].slice();return new Dt(t)},call:function(t,n){if((e=arguments.length-2)>0)for(var e,r,i=new Array(e),o=0;o<e;++o)i[o]=arguments[o+2];if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(o=0,e=(r=this._[t]).length;o<e;++o)r[o].value.apply(n,i)},apply:function(t,n,e){if(!this._.hasOwnProperty(t))throw new Error("unknown type: "+t);for(var r=this._[t],i=0,o=r.length;i<o;++i)r[i].value.apply(n,e)}};var qt="http://www.w3.org/1999/xhtml",Ut={svg:"http://www.w3.org/2000/svg",xhtml:qt,xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};function It(t){var n=t+="",e=n.indexOf(":");return e>=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),Ut.hasOwnProperty(n)?{space:Ut[n],local:t}:t}function Ot(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===qt&&n.documentElement.namespaceURI===qt?n.createElement(t):n.createElementNS(e,t)}}function Bt(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function Yt(t){var n=It(t);return(n.local?Bt:Ot)(n)}function Lt(){}function jt(t){return null==t?Lt:function(){return this.querySelector(t)}}function Ht(t){return null==t?[]:Array.isArray(t)?t:Array.from(t)}function Xt(){return[]}function Gt(t){return null==t?Xt:function(){return this.querySelectorAll(t)}}function Vt(t){return function(){return this.matches(t)}}function Wt(t){return function(n){return n.matches(t)}}var Zt=Array.prototype.find;function Kt(){return this.firstElementChild}var Qt=Array.prototype.filter;function Jt(){return Array.from(this.children)}function tn(t){return new Array(t.length)}function nn(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}function en(t,n,e,r,i,o){for(var a,u=0,c=n.length,f=o.length;u<f;++u)(a=n[u])?(a.__data__=o[u],r[u]=a):e[u]=new nn(t,o[u]);for(;u<c;++u)(a=n[u])&&(i[u]=a)}function rn(t,n,e,r,i,o,a){var u,c,f,s=new Map,l=n.length,h=o.length,d=new Array(l);for(u=0;u<l;++u)(c=n[u])&&(d[u]=f=a.call(c,c.__data__,u,n)+"",s.has(f)?i[u]=c:s.set(f,c));for(u=0;u<h;++u)f=a.call(t,o[u],u,o)+"",(c=s.get(f))?(r[u]=c,c.__data__=o[u],s.delete(f)):e[u]=new nn(t,o[u]);for(u=0;u<l;++u)(c=n[u])&&s.get(d[u])===c&&(i[u]=c)}function on(t){return t.__data__}function an(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}function un(t,n){return t<n?-1:t>n?1:t>=n?0:NaN}function cn(t){return function(){this.removeAttribute(t)}}function fn(t){return function(){this.removeAttributeNS(t.space,t.local)}}function sn(t,n){return function(){this.setAttribute(t,n)}}function ln(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}function hn(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}function dn(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}function pn(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function gn(t){return function(){this.style.removeProperty(t)}}function yn(t,n,e){return function(){this.style.setProperty(t,n,e)}}function vn(t,n,e){return function(){var r=n.apply(this,arguments);null==r?this.style.removeProperty(t):this.style.setProperty(t,r,e)}}function _n(t,n){return t.style.getPropertyValue(n)||pn(t).getComputedStyle(t,null).getPropertyValue(n)}function bn(t){return function(){delete this[t]}}function mn(t,n){return function(){this[t]=n}}function xn(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}function wn(t){return t.trim().split(/^|\s+/)}function Mn(t){return t.classList||new Tn(t)}function Tn(t){this._node=t,this._names=wn(t.getAttribute("class")||"")}function An(t,n){for(var e=Mn(t),r=-1,i=n.length;++r<i;)e.add(n[r])}function Sn(t,n){for(var e=Mn(t),r=-1,i=n.length;++r<i;)e.remove(n[r])}function En(t){return function(){An(this,t)}}function Nn(t){return function(){Sn(this,t)}}function kn(t,n){return function(){(n.apply(this,arguments)?An:Sn)(this,t)}}function Cn(){this.textContent=""}function Pn(t){return function(){this.textContent=t}}function zn(t){return function(){var n=t.apply(this,arguments);this.textContent=null==n?"":n}}function $n(){this.innerHTML=""}function Dn(t){return function(){this.innerHTML=t}}function Rn(t){return function(){var n=t.apply(this,arguments);this.innerHTML=null==n?"":n}}function Fn(){this.nextSibling&&this.parentNode.appendChild(this)}function qn(){this.previousSibling&&this.parentNode.insertBefore(this,this.parentNode.firstChild)}function Un(){return null}function In(){var t=this.parentNode;t&&t.removeChild(this)}function On(){var t=this.cloneNode(!1),n=this.parentNode;return n?n.insertBefore(t,this.nextSibling):t}function Bn(){var t=this.cloneNode(!0),n=this.parentNode;return n?n.insertBefore(t,this.nextSibling):t}function Yn(t){return function(){var n=this.__on;if(n){for(var e,r=0,i=-1,o=n.length;r<o;++r)e=n[r],t.type&&e.type!==t.type||e.name!==t.name?n[++i]=e:this.removeEventListener(e.type,e.listener,e.options);++i?n.length=i:delete this.__on}}}function Ln(t,n,e){return function(){var r,i=this.__on,o=function(t){return function(n){t.call(this,n,this.__data__)}}(n);if(i)for(var a=0,u=i.length;a<u;++a)if((r=i[a]).type===t.type&&r.name===t.name)return this.removeEventListener(r.type,r.listener,r.options),this.addEventListener(r.type,r.listener=o,r.options=e),void(r.value=n);this.addEventListener(t.type,o,e),r={type:t.type,name:t.name,value:n,listener:o,options:e},i?i.push(r):this.__on=[r]}}function jn(t,n,e){var r=pn(t),i=r.CustomEvent;"function"==typeof i?i=new i(n,e):(i=r.document.createEvent("Event"),e?(i.initEvent(n,e.bubbles,e.cancelable),i.detail=e.detail):i.initEvent(n,!1,!1)),t.dispatchEvent(i)}function Hn(t,n){return function(){return jn(this,t,n)}}function Xn(t,n){return function(){return jn(this,t,n.apply(this,arguments))}}nn.prototype={constructor:nn,appendChild:function(t){return this._parent.insertBefore(t,this._next)},insertBefore:function(t,n){return this._parent.insertBefore(t,n)},querySelector:function(t){return this._parent.querySelector(t)},querySelectorAll:function(t){return this._parent.querySelectorAll(t)}},Tn.prototype={add:function(t){this._names.indexOf(t)<0&&(this._names.push(t),this._node.setAttribute("class",this._names.join(" ")))},remove:function(t){var n=this._names.indexOf(t);n>=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var Gn=[null];function Vn(t,n){this._groups=t,this._parents=n}function Wn(){return new Vn([[document.documentElement]],Gn)}function Zn(t){return"string"==typeof t?new Vn([[document.querySelector(t)]],[document.documentElement]):new Vn([[t]],Gn)}Vn.prototype=Wn.prototype={constructor:Vn,select:function(t){"function"!=typeof t&&(t=jt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a,u=n[i],c=u.length,f=r[i]=new Array(c),s=0;s<c;++s)(o=u[s])&&(a=t.call(o,o.__data__,s,u))&&("__data__"in o&&(a.__data__=o.__data__),f[s]=a);return new Vn(r,this._parents)},selectAll:function(t){t="function"==typeof t?function(t){return function(){return Ht(t.apply(this,arguments))}}(t):Gt(t);for(var n=this._groups,e=n.length,r=[],i=[],o=0;o<e;++o)for(var a,u=n[o],c=u.length,f=0;f<c;++f)(a=u[f])&&(r.push(t.call(a,a.__data__,f,u)),i.push(a));return new Vn(r,i)},selectChild:function(t){return this.select(null==t?Kt:function(t){return function(){return Zt.call(this.children,t)}}("function"==typeof t?t:Wt(t)))},selectChildren:function(t){return this.selectAll(null==t?Jt:function(t){return function(){return Qt.call(this.children,t)}}("function"==typeof t?t:Wt(t)))},filter:function(t){"function"!=typeof t&&(t=Vt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a=n[i],u=a.length,c=r[i]=[],f=0;f<u;++f)(o=a[f])&&t.call(o,o.__data__,f,a)&&c.push(o);return new Vn(r,this._parents)},data:function(t,n){if(!arguments.length)return Array.from(this,on);var e=n?rn:en,r=this._parents,i=this._groups;"function"!=typeof t&&(t=function(t){return function(){return t}}(t));for(var o=i.length,a=new Array(o),u=new Array(o),c=new Array(o),f=0;f<o;++f){var s=r[f],l=i[f],h=l.length,d=an(t.call(s,s&&s.__data__,f,r)),p=d.length,g=u[f]=new Array(p),y=a[f]=new Array(p);e(s,l,g,y,c[f]=new Array(h),d,n);for(var v,_,b=0,m=0;b<p;++b)if(v=g[b]){for(b>=m&&(m=b+1);!(_=y[m])&&++m<p;);v._next=_||null}}return(a=new Vn(a,r))._enter=u,a._exit=c,a},enter:function(){return new Vn(this._enter||this._groups.map(tn),this._parents)},exit:function(){return new Vn(this._exit||this._groups.map(tn),this._parents)},join:function(t,n,e){var r=this.enter(),i=this,o=this.exit();return"function"==typeof t?(r=t(r))&&(r=r.selection()):r=r.append(t+""),null!=n&&(i=n(i))&&(i=i.selection()),null==e?o.remove():e(o),r&&i?r.merge(i).order():i},merge:function(t){for(var n=t.selection?t.selection():t,e=this._groups,r=n._groups,i=e.length,o=r.length,a=Math.min(i,o),u=new Array(i),c=0;c<a;++c)for(var f,s=e[c],l=r[c],h=s.length,d=u[c]=new Array(h),p=0;p<h;++p)(f=s[p]||l[p])&&(d[p]=f);for(;c<i;++c)u[c]=e[c];return new Vn(u,this._parents)},selection:function(){return this},order:function(){for(var t=this._groups,n=-1,e=t.length;++n<e;)for(var r,i=t[n],o=i.length-1,a=i[o];--o>=0;)(r=i[o])&&(a&&4^r.compareDocumentPosition(a)&&a.parentNode.insertBefore(r,a),a=r);return this},sort:function(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=un);for(var e=this._groups,r=e.length,i=new Array(r),o=0;o<r;++o){for(var a,u=e[o],c=u.length,f=i[o]=new Array(c),s=0;s<c;++s)(a=u[s])&&(f[s]=a);f.sort(n)}return new Vn(i,this._parents).order()},call:function(){var t=arguments[0];return arguments[0]=this,t.apply(null,arguments),this},nodes:function(){return Array.from(this)},node:function(){for(var t=this._groups,n=0,e=t.length;n<e;++n)for(var r=t[n],i=0,o=r.length;i<o;++i){var a=r[i];if(a)return a}return null},size:function(){let t=0;for(const n of this)++t;return t},empty:function(){return!this.node()},each:function(t){for(var n=this._groups,e=0,r=n.length;e<r;++e)for(var i,o=n[e],a=0,u=o.length;a<u;++a)(i=o[a])&&t.call(i,i.__data__,a,o);return this},attr:function(t,n){var e=It(t);if(arguments.length<2){var r=this.node();return e.local?r.getAttributeNS(e.space,e.local):r.getAttribute(e)}return this.each((null==n?e.local?fn:cn:"function"==typeof n?e.local?dn:hn:e.local?ln:sn)(e,n))},style:function(t,n,e){return arguments.length>1?this.each((null==n?gn:"function"==typeof n?vn:yn)(t,n,null==e?"":e)):_n(this.node(),t)},property:function(t,n){return arguments.length>1?this.each((null==n?bn:"function"==typeof n?xn:mn)(t,n)):this.node()[t]},classed:function(t,n){var e=wn(t+"");if(arguments.length<2){for(var r=Mn(this.node()),i=-1,o=e.length;++i<o;)if(!r.contains(e[i]))return!1;return!0}return this.each(("function"==typeof n?kn:n?En:Nn)(e,n))},text:function(t){return arguments.length?this.each(null==t?Cn:("function"==typeof t?zn:Pn)(t)):this.node().textContent},html:function(t){return arguments.length?this.each(null==t?$n:("function"==typeof t?Rn:Dn)(t)):this.node().innerHTML},raise:function(){return this.each(Fn)},lower:function(){return this.each(qn)},append:function(t){var n="function"==typeof t?t:Yt(t);return this.select((function(){return this.appendChild(n.apply(this,arguments))}))},insert:function(t,n){var e="function"==typeof t?t:Yt(t),r=null==n?Un:"function"==typeof n?n:jt(n);return this.select((function(){return this.insertBefore(e.apply(this,arguments),r.apply(this,arguments)||null)}))},remove:function(){return this.each(In)},clone:function(t){return this.select(t?Bn:On)},datum:function(t){return arguments.length?this.property("__data__",t):this.node().__data__},on:function(t,n,e){var r,i,o=function(t){return t.trim().split(/^|\s+/).map((function(t){var n="",e=t.indexOf(".");return e>=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}}))}(t+""),a=o.length;if(!(arguments.length<2)){for(u=n?Ln:Yn,r=0;r<a;++r)this.each(u(o[r],n,e));return this}var u=this.node().__on;if(u)for(var c,f=0,s=u.length;f<s;++f)for(r=0,c=u[f];r<a;++r)if((i=o[r]).type===c.type&&i.name===c.name)return c.value},dispatch:function(t,n){return this.each(("function"==typeof n?Xn:Hn)(t,n))},[Symbol.iterator]:function*(){for(var t=this._groups,n=0,e=t.length;n<e;++n)for(var r,i=t[n],o=0,a=i.length;o<a;++o)(r=i[o])&&(yield r)}};var Kn=0;function Qn(){return new Jn}function Jn(){this._="@"+(++Kn).toString(36)}function te(t){let n;for(;n=t.sourceEvent;)t=n;return t}function ne(t,n){if(t=te(t),void 0===n&&(n=t.currentTarget),n){var e=n.ownerSVGElement||n;if(e.createSVGPoint){var r=e.createSVGPoint();return r.x=t.clientX,r.y=t.clientY,[(r=r.matrixTransform(n.getScreenCTM().inverse())).x,r.y]}if(n.getBoundingClientRect){var i=n.getBoundingClientRect();return[t.clientX-i.left-n.clientLeft,t.clientY-i.top-n.clientTop]}}return[t.pageX,t.pageY]}Jn.prototype=Qn.prototype={constructor:Jn,get:function(t){for(var n=this._;!(n in t);)if(!(t=t.parentNode))return;return t[n]},set:function(t,n){return t[this._]=n},remove:function(t){return this._ in t&&delete t[this._]},toString:function(){return this._}};const ee={passive:!1},re={capture:!0,passive:!1};function ie(t){t.stopImmediatePropagation()}function oe(t){t.preventDefault(),t.stopImmediatePropagation()}function ae(t){var n=t.document.documentElement,e=Zn(t).on("dragstart.drag",oe,re);"onselectstart"in n?e.on("selectstart.drag",oe,re):(n.__noselect=n.style.MozUserSelect,n.style.MozUserSelect="none")}function ue(t,n){var e=t.document.documentElement,r=Zn(t).on("dragstart.drag",null);n&&(r.on("click.drag",oe,re),setTimeout((function(){r.on("click.drag",null)}),0)),"onselectstart"in e?r.on("selectstart.drag",null):(e.style.MozUserSelect=e.__noselect,delete e.__noselect)}var ce=t=>()=>t;function fe(t,{sourceEvent:n,subject:e,target:r,identifier:i,active:o,x:a,y:u,dx:c,dy:f,dispatch:s}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},subject:{value:e,enumerable:!0,configurable:!0},target:{value:r,enumerable:!0,configurable:!0},identifier:{value:i,enumerable:!0,configurable:!0},active:{value:o,enumerable:!0,configurable:!0},x:{value:a,enumerable:!0,configurable:!0},y:{value:u,enumerable:!0,configurable:!0},dx:{value:c,enumerable:!0,configurable:!0},dy:{value:f,enumerable:!0,configurable:!0},_:{value:s}})}function se(t){return!t.ctrlKey&&!t.button}function le(){return this.parentNode}function he(t,n){return null==n?{x:t.x,y:t.y}:n}function de(){return navigator.maxTouchPoints||"ontouchstart"in this}function pe(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function ge(t,n){var e=Object.create(t.prototype);for(var r in n)e[r]=n[r];return e}function ye(){}fe.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var ve=.7,_e=1/ve,be="\\s*([+-]?\\d+)\\s*",me="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",xe="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",we=/^#([0-9a-f]{3,8})$/,Me=new RegExp(`^rgb\\(${be},${be},${be}\\)$`),Te=new RegExp(`^rgb\\(${xe},${xe},${xe}\\)$`),Ae=new RegExp(`^rgba\\(${be},${be},${be},${me}\\)$`),Se=new RegExp(`^rgba\\(${xe},${xe},${xe},${me}\\)$`),Ee=new RegExp(`^hsl\\(${me},${xe},${xe}\\)$`),Ne=new RegExp(`^hsla\\(${me},${xe},${xe},${me}\\)$`),ke={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function Ce(){return this.rgb().formatHex()}function Pe(){return this.rgb().formatRgb()}function ze(t){var n,e;return t=(t+"").trim().toLowerCase(),(n=we.exec(t))?(e=n[1].length,n=parseInt(n[1],16),6===e?$e(n):3===e?new qe(n>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1):8===e?De(n>>24&255,n>>16&255,n>>8&255,(255&n)/255):4===e?De(n>>12&15|n>>8&240,n>>8&15|n>>4&240,n>>4&15|240&n,((15&n)<<4|15&n)/255):null):(n=Me.exec(t))?new qe(n[1],n[2],n[3],1):(n=Te.exec(t))?new qe(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=Ae.exec(t))?De(n[1],n[2],n[3],n[4]):(n=Se.exec(t))?De(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=Ee.exec(t))?Le(n[1],n[2]/100,n[3]/100,1):(n=Ne.exec(t))?Le(n[1],n[2]/100,n[3]/100,n[4]):ke.hasOwnProperty(t)?$e(ke[t]):"transparent"===t?new qe(NaN,NaN,NaN,0):null}function $e(t){return new qe(t>>16&255,t>>8&255,255&t,1)}function De(t,n,e,r){return r<=0&&(t=n=e=NaN),new qe(t,n,e,r)}function Re(t){return t instanceof ye||(t=ze(t)),t?new qe((t=t.rgb()).r,t.g,t.b,t.opacity):new qe}function Fe(t,n,e,r){return 1===arguments.length?Re(t):new qe(t,n,e,null==r?1:r)}function qe(t,n,e,r){this.r=+t,this.g=+n,this.b=+e,this.opacity=+r}function Ue(){return`#${Ye(this.r)}${Ye(this.g)}${Ye(this.b)}`}function Ie(){const t=Oe(this.opacity);return`${1===t?"rgb(":"rgba("}${Be(this.r)}, ${Be(this.g)}, ${Be(this.b)}${1===t?")":`, ${t})`}`}function Oe(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function Be(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function Ye(t){return((t=Be(t))<16?"0":"")+t.toString(16)}function Le(t,n,e,r){return r<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new Xe(t,n,e,r)}function je(t){if(t instanceof Xe)return new Xe(t.h,t.s,t.l,t.opacity);if(t instanceof ye||(t=ze(t)),!t)return new Xe;if(t instanceof Xe)return t;var n=(t=t.rgb()).r/255,e=t.g/255,r=t.b/255,i=Math.min(n,e,r),o=Math.max(n,e,r),a=NaN,u=o-i,c=(o+i)/2;return u?(a=n===o?(e-r)/u+6*(e<r):e===o?(r-n)/u+2:(n-e)/u+4,u/=c<.5?o+i:2-o-i,a*=60):u=c>0&&c<1?0:a,new Xe(a,u,c,t.opacity)}function He(t,n,e,r){return 1===arguments.length?je(t):new Xe(t,n,e,null==r?1:r)}function Xe(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Ge(t){return(t=(t||0)%360)<0?t+360:t}function Ve(t){return Math.max(0,Math.min(1,t||0))}function We(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}pe(ye,ze,{copy(t){return Object.assign(new this.constructor,this,t)},displayable(){return this.rgb().displayable()},hex:Ce,formatHex:Ce,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return je(this).formatHsl()},formatRgb:Pe,toString:Pe}),pe(qe,Fe,ge(ye,{brighter(t){return t=null==t?_e:Math.pow(_e,t),new qe(this.r*t,this.g*t,this.b*t,this.opacity)},darker(t){return t=null==t?ve:Math.pow(ve,t),new qe(this.r*t,this.g*t,this.b*t,this.opacity)},rgb(){return this},clamp(){return new qe(Be(this.r),Be(this.g),Be(this.b),Oe(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Ue,formatHex:Ue,formatHex8:function(){return`#${Ye(this.r)}${Ye(this.g)}${Ye(this.b)}${Ye(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:Ie,toString:Ie})),pe(Xe,He,ge(ye,{brighter(t){return t=null==t?_e:Math.pow(_e,t),new Xe(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=null==t?ve:Math.pow(ve,t),new Xe(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,r=e+(e<.5?e:1-e)*n,i=2*e-r;return new qe(We(t>=240?t-240:t+120,i,r),We(t,i,r),We(t<120?t+240:t-120,i,r),this.opacity)},clamp(){return new Xe(Ge(this.h),Ve(this.s),Ve(this.l),Oe(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const t=Oe(this.opacity);return`${1===t?"hsl(":"hsla("}${Ge(this.h)}, ${100*Ve(this.s)}%, ${100*Ve(this.l)}%${1===t?")":`, ${t})`}`}}));const Ze=Math.PI/180,Ke=180/Math.PI,Qe=.96422,Je=1,tr=.82521,nr=4/29,er=6/29,rr=3*er*er,ir=er*er*er;function or(t){if(t instanceof ur)return new ur(t.l,t.a,t.b,t.opacity);if(t instanceof pr)return gr(t);t instanceof qe||(t=Re(t));var n,e,r=lr(t.r),i=lr(t.g),o=lr(t.b),a=cr((.2225045*r+.7168786*i+.0606169*o)/Je);return r===i&&i===o?n=e=a:(n=cr((.4360747*r+.3850649*i+.1430804*o)/Qe),e=cr((.0139322*r+.0971045*i+.7141733*o)/tr)),new ur(116*a-16,500*(n-a),200*(a-e),t.opacity)}function ar(t,n,e,r){return 1===arguments.length?or(t):new ur(t,n,e,null==r?1:r)}function ur(t,n,e,r){this.l=+t,this.a=+n,this.b=+e,this.opacity=+r}function cr(t){return t>ir?Math.pow(t,1/3):t/rr+nr}function fr(t){return t>er?t*t*t:rr*(t-nr)}function sr(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function lr(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function hr(t){if(t instanceof pr)return new pr(t.h,t.c,t.l,t.opacity);if(t instanceof ur||(t=or(t)),0===t.a&&0===t.b)return new pr(NaN,0<t.l&&t.l<100?0:NaN,t.l,t.opacity);var n=Math.atan2(t.b,t.a)*Ke;return new pr(n<0?n+360:n,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}function dr(t,n,e,r){return 1===arguments.length?hr(t):new pr(t,n,e,null==r?1:r)}function pr(t,n,e,r){this.h=+t,this.c=+n,this.l=+e,this.opacity=+r}function gr(t){if(isNaN(t.h))return new ur(t.l,0,0,t.opacity);var n=t.h*Ze;return new ur(t.l,Math.cos(n)*t.c,Math.sin(n)*t.c,t.opacity)}pe(ur,ar,ge(ye,{brighter(t){return new ur(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker(t){return new ur(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb(){var t=(this.l+16)/116,n=isNaN(this.a)?t:t+this.a/500,e=isNaN(this.b)?t:t-this.b/200;return new qe(sr(3.1338561*(n=Qe*fr(n))-1.6168667*(t=Je*fr(t))-.4906146*(e=tr*fr(e))),sr(-.9787684*n+1.9161415*t+.033454*e),sr(.0719453*n-.2289914*t+1.4052427*e),this.opacity)}})),pe(pr,dr,ge(ye,{brighter(t){return new pr(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker(t){return new pr(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb(){return gr(this).rgb()}}));var yr=-.14861,vr=1.78277,_r=-.29227,br=-.90649,mr=1.97294,xr=mr*br,wr=mr*vr,Mr=vr*_r-br*yr;function Tr(t,n,e,r){return 1===arguments.length?function(t){if(t instanceof Ar)return new Ar(t.h,t.s,t.l,t.opacity);t instanceof qe||(t=Re(t));var n=t.r/255,e=t.g/255,r=t.b/255,i=(Mr*r+xr*n-wr*e)/(Mr+xr-wr),o=r-i,a=(mr*(e-i)-_r*o)/br,u=Math.sqrt(a*a+o*o)/(mr*i*(1-i)),c=u?Math.atan2(a,o)*Ke-120:NaN;return new Ar(c<0?c+360:c,u,i,t.opacity)}(t):new Ar(t,n,e,null==r?1:r)}function Ar(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Sr(t,n,e,r,i){var o=t*t,a=o*t;return((1-3*t+3*o-a)*n+(4-6*o+3*a)*e+(1+3*t+3*o-3*a)*r+a*i)/6}function Er(t){var n=t.length-1;return function(e){var r=e<=0?e=0:e>=1?(e=1,n-1):Math.floor(e*n),i=t[r],o=t[r+1],a=r>0?t[r-1]:2*i-o,u=r<n-1?t[r+2]:2*o-i;return Sr((e-r/n)*n,a,i,o,u)}}function Nr(t){var n=t.length;return function(e){var r=Math.floor(((e%=1)<0?++e:e)*n),i=t[(r+n-1)%n],o=t[r%n],a=t[(r+1)%n],u=t[(r+2)%n];return Sr((e-r/n)*n,i,o,a,u)}}pe(Ar,Tr,ge(ye,{brighter(t){return t=null==t?_e:Math.pow(_e,t),new Ar(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=null==t?ve:Math.pow(ve,t),new Ar(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=isNaN(this.h)?0:(this.h+120)*Ze,n=+this.l,e=isNaN(this.s)?0:this.s*n*(1-n),r=Math.cos(t),i=Math.sin(t);return new qe(255*(n+e*(yr*r+vr*i)),255*(n+e*(_r*r+br*i)),255*(n+e*(mr*r)),this.opacity)}}));var kr=t=>()=>t;function Cr(t,n){return function(e){return t+e*n}}function Pr(t,n){var e=n-t;return e?Cr(t,e>180||e<-180?e-360*Math.round(e/360):e):kr(isNaN(t)?n:t)}function zr(t){return 1==(t=+t)?$r:function(n,e){return e-n?function(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(r){return Math.pow(t+r*n,e)}}(n,e,t):kr(isNaN(n)?e:n)}}function $r(t,n){var e=n-t;return e?Cr(t,e):kr(isNaN(t)?n:t)}var Dr=function t(n){var e=zr(n);function r(t,n){var r=e((t=Fe(t)).r,(n=Fe(n)).r),i=e(t.g,n.g),o=e(t.b,n.b),a=$r(t.opacity,n.opacity);return function(n){return t.r=r(n),t.g=i(n),t.b=o(n),t.opacity=a(n),t+""}}return r.gamma=t,r}(1);function Rr(t){return function(n){var e,r,i=n.length,o=new Array(i),a=new Array(i),u=new Array(i);for(e=0;e<i;++e)r=Fe(n[e]),o[e]=r.r||0,a[e]=r.g||0,u[e]=r.b||0;return o=t(o),a=t(a),u=t(u),r.opacity=1,function(t){return r.r=o(t),r.g=a(t),r.b=u(t),r+""}}}var Fr=Rr(Er),qr=Rr(Nr);function Ur(t,n){n||(n=[]);var e,r=t?Math.min(n.length,t.length):0,i=n.slice();return function(o){for(e=0;e<r;++e)i[e]=t[e]*(1-o)+n[e]*o;return i}}function Ir(t){return ArrayBuffer.isView(t)&&!(t instanceof DataView)}function Or(t,n){var e,r=n?n.length:0,i=t?Math.min(r,t.length):0,o=new Array(i),a=new Array(r);for(e=0;e<i;++e)o[e]=Gr(t[e],n[e]);for(;e<r;++e)a[e]=n[e];return function(t){for(e=0;e<i;++e)a[e]=o[e](t);return a}}function Br(t,n){var e=new Date;return t=+t,n=+n,function(r){return e.setTime(t*(1-r)+n*r),e}}function Yr(t,n){return t=+t,n=+n,function(e){return t*(1-e)+n*e}}function Lr(t,n){var e,r={},i={};for(e in null!==t&&"object"==typeof t||(t={}),null!==n&&"object"==typeof n||(n={}),n)e in t?r[e]=Gr(t[e],n[e]):i[e]=n[e];return function(t){for(e in r)i[e]=r[e](t);return i}}var jr=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,Hr=new RegExp(jr.source,"g");function Xr(t,n){var e,r,i,o=jr.lastIndex=Hr.lastIndex=0,a=-1,u=[],c=[];for(t+="",n+="";(e=jr.exec(t))&&(r=Hr.exec(n));)(i=r.index)>o&&(i=n.slice(o,i),u[a]?u[a]+=i:u[++a]=i),(e=e[0])===(r=r[0])?u[a]?u[a]+=r:u[++a]=r:(u[++a]=null,c.push({i:a,x:Yr(e,r)})),o=Hr.lastIndex;return o<n.length&&(i=n.slice(o),u[a]?u[a]+=i:u[++a]=i),u.length<2?c[0]?function(t){return function(n){return t(n)+""}}(c[0].x):function(t){return function(){return t}}(n):(n=c.length,function(t){for(var e,r=0;r<n;++r)u[(e=c[r]).i]=e.x(t);return u.join("")})}function Gr(t,n){var e,r=typeof n;return null==n||"boolean"===r?kr(n):("number"===r?Yr:"string"===r?(e=ze(n))?(n=e,Dr):Xr:n instanceof ze?Dr:n instanceof Date?Br:Ir(n)?Ur:Array.isArray(n)?Or:"function"!=typeof n.valueOf&&"function"!=typeof n.toString||isNaN(n)?Lr:Yr)(t,n)}function Vr(t,n){return t=+t,n=+n,function(e){return Math.round(t*(1-e)+n*e)}}var Wr,Zr=180/Math.PI,Kr={translateX:0,translateY:0,rotate:0,skewX:0,scaleX:1,scaleY:1};function Qr(t,n,e,r,i,o){var a,u,c;return(a=Math.sqrt(t*t+n*n))&&(t/=a,n/=a),(c=t*e+n*r)&&(e-=t*c,r-=n*c),(u=Math.sqrt(e*e+r*r))&&(e/=u,r/=u,c/=u),t*r<n*e&&(t=-t,n=-n,c=-c,a=-a),{translateX:i,translateY:o,rotate:Math.atan2(n,t)*Zr,skewX:Math.atan(c)*Zr,scaleX:a,scaleY:u}}function Jr(t,n,e,r){function i(t){return t.length?t.pop()+" ":""}return function(o,a){var u=[],c=[];return o=t(o),a=t(a),function(t,r,i,o,a,u){if(t!==i||r!==o){var c=a.push("translate(",null,n,null,e);u.push({i:c-4,x:Yr(t,i)},{i:c-2,x:Yr(r,o)})}else(i||o)&&a.push("translate("+i+n+o+e)}(o.translateX,o.translateY,a.translateX,a.translateY,u,c),function(t,n,e,o){t!==n?(t-n>180?n+=360:n-t>180&&(t+=360),o.push({i:e.push(i(e)+"rotate(",null,r)-2,x:Yr(t,n)})):n&&e.push(i(e)+"rotate("+n+r)}(o.rotate,a.rotate,u,c),function(t,n,e,o){t!==n?o.push({i:e.push(i(e)+"skewX(",null,r)-2,x:Yr(t,n)}):n&&e.push(i(e)+"skewX("+n+r)}(o.skewX,a.skewX,u,c),function(t,n,e,r,o,a){if(t!==e||n!==r){var u=o.push(i(o)+"scale(",null,",",null,")");a.push({i:u-4,x:Yr(t,e)},{i:u-2,x:Yr(n,r)})}else 1===e&&1===r||o.push(i(o)+"scale("+e+","+r+")")}(o.scaleX,o.scaleY,a.scaleX,a.scaleY,u,c),o=a=null,function(t){for(var n,e=-1,r=c.length;++e<r;)u[(n=c[e]).i]=n.x(t);return u.join("")}}}var ti=Jr((function(t){const n=new("function"==typeof DOMMatrix?DOMMatrix:WebKitCSSMatrix)(t+"");return n.isIdentity?Kr:Qr(n.a,n.b,n.c,n.d,n.e,n.f)}),"px, ","px)","deg)"),ni=Jr((function(t){return null==t?Kr:(Wr||(Wr=document.createElementNS("http://www.w3.org/2000/svg","g")),Wr.setAttribute("transform",t),(t=Wr.transform.baseVal.consolidate())?Qr((t=t.matrix).a,t.b,t.c,t.d,t.e,t.f):Kr)}),", ",")",")");function ei(t){return((t=Math.exp(t))+1/t)/2}var ri=function t(n,e,r){function i(t,i){var o,a,u=t[0],c=t[1],f=t[2],s=i[0],l=i[1],h=i[2],d=s-u,p=l-c,g=d*d+p*p;if(g<1e-12)a=Math.log(h/f)/n,o=function(t){return[u+t*d,c+t*p,f*Math.exp(n*t*a)]};else{var y=Math.sqrt(g),v=(h*h-f*f+r*g)/(2*f*e*y),_=(h*h-f*f-r*g)/(2*h*e*y),b=Math.log(Math.sqrt(v*v+1)-v),m=Math.log(Math.sqrt(_*_+1)-_);a=(m-b)/n,o=function(t){var r=t*a,i=ei(b),o=f/(e*y)*(i*function(t){return((t=Math.exp(2*t))-1)/(t+1)}(n*r+b)-function(t){return((t=Math.exp(t))-1/t)/2}(b));return[u+o*d,c+o*p,f*i/ei(n*r+b)]}}return o.duration=1e3*a*n/Math.SQRT2,o}return i.rho=function(n){var e=Math.max(.001,+n),r=e*e;return t(e,r,r*r)},i}(Math.SQRT2,2,4);function ii(t){return function(n,e){var r=t((n=He(n)).h,(e=He(e)).h),i=$r(n.s,e.s),o=$r(n.l,e.l),a=$r(n.opacity,e.opacity);return function(t){return n.h=r(t),n.s=i(t),n.l=o(t),n.opacity=a(t),n+""}}}var oi=ii(Pr),ai=ii($r);function ui(t){return function(n,e){var r=t((n=dr(n)).h,(e=dr(e)).h),i=$r(n.c,e.c),o=$r(n.l,e.l),a=$r(n.opacity,e.opacity);return function(t){return n.h=r(t),n.c=i(t),n.l=o(t),n.opacity=a(t),n+""}}}var ci=ui(Pr),fi=ui($r);function si(t){return function n(e){function r(n,r){var i=t((n=Tr(n)).h,(r=Tr(r)).h),o=$r(n.s,r.s),a=$r(n.l,r.l),u=$r(n.opacity,r.opacity);return function(t){return n.h=i(t),n.s=o(t),n.l=a(Math.pow(t,e)),n.opacity=u(t),n+""}}return e=+e,r.gamma=n,r}(1)}var li=si(Pr),hi=si($r);function di(t,n){void 0===n&&(n=t,t=Gr);for(var e=0,r=n.length-1,i=n[0],o=new Array(r<0?0:r);e<r;)o[e]=t(i,i=n[++e]);return function(t){var n=Math.max(0,Math.min(r-1,Math.floor(t*=r)));return o[n](t-n)}}var pi,gi,yi=0,vi=0,_i=0,bi=1e3,mi=0,xi=0,wi=0,Mi="object"==typeof performance&&performance.now?performance:Date,Ti="object"==typeof window&&window.requestAnimationFrame?window.requestAnimationFrame.bind(window):function(t){setTimeout(t,17)};function Ai(){return xi||(Ti(Si),xi=Mi.now()+wi)}function Si(){xi=0}function Ei(){this._call=this._time=this._next=null}function Ni(t,n,e){var r=new Ei;return r.restart(t,n,e),r}function ki(){Ai(),++yi;for(var t,n=pi;n;)(t=xi-n._time)>=0&&n._call.call(void 0,t),n=n._next;--yi}function Ci(){xi=(mi=Mi.now())+wi,yi=vi=0;try{ki()}finally{yi=0,function(){var t,n,e=pi,r=1/0;for(;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:pi=n);gi=t,zi(r)}(),xi=0}}function Pi(){var t=Mi.now(),n=t-mi;n>bi&&(wi-=n,mi=t)}function zi(t){yi||(vi&&(vi=clearTimeout(vi)),t-xi>24?(t<1/0&&(vi=setTimeout(Ci,t-Mi.now()-wi)),_i&&(_i=clearInterval(_i))):(_i||(mi=Mi.now(),_i=setInterval(Pi,bi)),yi=1,Ti(Ci)))}function $i(t,n,e){var r=new Ei;return n=null==n?0:+n,r.restart((e=>{r.stop(),t(e+n)}),n,e),r}Ei.prototype=Ni.prototype={constructor:Ei,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?Ai():+e)+(null==n?0:+n),this._next||gi===this||(gi?gi._next=this:pi=this,gi=this),this._call=t,this._time=e,zi()},stop:function(){this._call&&(this._call=null,this._time=1/0,zi())}};var Di=$t("start","end","cancel","interrupt"),Ri=[],Fi=0,qi=1,Ui=2,Ii=3,Oi=4,Bi=5,Yi=6;function Li(t,n,e,r,i,o){var a=t.__transition;if(a){if(e in a)return}else t.__transition={};!function(t,n,e){var r,i=t.__transition;function o(t){e.state=qi,e.timer.restart(a,e.delay,e.time),e.delay<=t&&a(t-e.delay)}function a(o){var f,s,l,h;if(e.state!==qi)return c();for(f in i)if((h=i[f]).name===e.name){if(h.state===Ii)return $i(a);h.state===Oi?(h.state=Yi,h.timer.stop(),h.on.call("interrupt",t,t.__data__,h.index,h.group),delete i[f]):+f<n&&(h.state=Yi,h.timer.stop(),h.on.call("cancel",t,t.__data__,h.index,h.group),delete i[f])}if($i((function(){e.state===Ii&&(e.state=Oi,e.timer.restart(u,e.delay,e.time),u(o))})),e.state=Ui,e.on.call("start",t,t.__data__,e.index,e.group),e.state===Ui){for(e.state=Ii,r=new Array(l=e.tween.length),f=0,s=-1;f<l;++f)(h=e.tween[f].value.call(t,t.__data__,e.index,e.group))&&(r[++s]=h);r.length=s+1}}function u(n){for(var i=n<e.duration?e.ease.call(null,n/e.duration):(e.timer.restart(c),e.state=Bi,1),o=-1,a=r.length;++o<a;)r[o].call(t,i);e.state===Bi&&(e.on.call("end",t,t.__data__,e.index,e.group),c())}function c(){for(var r in e.state=Yi,e.timer.stop(),delete i[n],i)return;delete t.__transition}i[n]=e,e.timer=Ni(o,0,e.time)}(t,e,{name:n,index:r,group:i,on:Di,tween:Ri,time:o.time,delay:o.delay,duration:o.duration,ease:o.ease,timer:null,state:Fi})}function ji(t,n){var e=Xi(t,n);if(e.state>Fi)throw new Error("too late; already scheduled");return e}function Hi(t,n){var e=Xi(t,n);if(e.state>Ii)throw new Error("too late; already running");return e}function Xi(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("transition not found");return e}function Gi(t,n){var e,r,i,o=t.__transition,a=!0;if(o){for(i in n=null==n?null:n+"",o)(e=o[i]).name===n?(r=e.state>Ui&&e.state<Bi,e.state=Yi,e.timer.stop(),e.on.call(r?"interrupt":"cancel",t,t.__data__,e.index,e.group),delete o[i]):a=!1;a&&delete t.__transition}}function Vi(t,n){var e,r;return function(){var i=Hi(this,t),o=i.tween;if(o!==e)for(var a=0,u=(r=e=o).length;a<u;++a)if(r[a].name===n){(r=r.slice()).splice(a,1);break}i.tween=r}}function Wi(t,n,e){var r,i;if("function"!=typeof e)throw new Error;return function(){var o=Hi(this,t),a=o.tween;if(a!==r){i=(r=a).slice();for(var u={name:n,value:e},c=0,f=i.length;c<f;++c)if(i[c].name===n){i[c]=u;break}c===f&&i.push(u)}o.tween=i}}function Zi(t,n,e){var r=t._id;return t.each((function(){var t=Hi(this,r);(t.value||(t.value={}))[n]=e.apply(this,arguments)})),function(t){return Xi(t,r).value[n]}}function Ki(t,n){var e;return("number"==typeof n?Yr:n instanceof ze?Dr:(e=ze(n))?(n=e,Dr):Xr)(t,n)}function Qi(t){return function(){this.removeAttribute(t)}}function Ji(t){return function(){this.removeAttributeNS(t.space,t.local)}}function to(t,n,e){var r,i,o=e+"";return function(){var a=this.getAttribute(t);return a===o?null:a===r?i:i=n(r=a,e)}}function no(t,n,e){var r,i,o=e+"";return function(){var a=this.getAttributeNS(t.space,t.local);return a===o?null:a===r?i:i=n(r=a,e)}}function eo(t,n,e){var r,i,o;return function(){var a,u,c=e(this);if(null!=c)return(a=this.getAttribute(t))===(u=c+"")?null:a===r&&u===i?o:(i=u,o=n(r=a,c));this.removeAttribute(t)}}function ro(t,n,e){var r,i,o;return function(){var a,u,c=e(this);if(null!=c)return(a=this.getAttributeNS(t.space,t.local))===(u=c+"")?null:a===r&&u===i?o:(i=u,o=n(r=a,c));this.removeAttributeNS(t.space,t.local)}}function io(t,n){var e,r;function i(){var i=n.apply(this,arguments);return i!==r&&(e=(r=i)&&function(t,n){return function(e){this.setAttributeNS(t.space,t.local,n.call(this,e))}}(t,i)),e}return i._value=n,i}function oo(t,n){var e,r;function i(){var i=n.apply(this,arguments);return i!==r&&(e=(r=i)&&function(t,n){return function(e){this.setAttribute(t,n.call(this,e))}}(t,i)),e}return i._value=n,i}function ao(t,n){return function(){ji(this,t).delay=+n.apply(this,arguments)}}function uo(t,n){return n=+n,function(){ji(this,t).delay=n}}function co(t,n){return function(){Hi(this,t).duration=+n.apply(this,arguments)}}function fo(t,n){return n=+n,function(){Hi(this,t).duration=n}}var so=Wn.prototype.constructor;function lo(t){return function(){this.style.removeProperty(t)}}var ho=0;function po(t,n,e,r){this._groups=t,this._parents=n,this._name=e,this._id=r}function go(t){return Wn().transition(t)}function yo(){return++ho}var vo=Wn.prototype;po.prototype=go.prototype={constructor:po,select:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=jt(t));for(var r=this._groups,i=r.length,o=new Array(i),a=0;a<i;++a)for(var u,c,f=r[a],s=f.length,l=o[a]=new Array(s),h=0;h<s;++h)(u=f[h])&&(c=t.call(u,u.__data__,h,f))&&("__data__"in u&&(c.__data__=u.__data__),l[h]=c,Li(l[h],n,e,h,l,Xi(u,e)));return new po(o,this._parents,n,e)},selectAll:function(t){var n=this._name,e=this._id;"function"!=typeof t&&(t=Gt(t));for(var r=this._groups,i=r.length,o=[],a=[],u=0;u<i;++u)for(var c,f=r[u],s=f.length,l=0;l<s;++l)if(c=f[l]){for(var h,d=t.call(c,c.__data__,l,f),p=Xi(c,e),g=0,y=d.length;g<y;++g)(h=d[g])&&Li(h,n,e,g,d,p);o.push(d),a.push(c)}return new po(o,a,n,e)},selectChild:vo.selectChild,selectChildren:vo.selectChildren,filter:function(t){"function"!=typeof t&&(t=Vt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i<e;++i)for(var o,a=n[i],u=a.length,c=r[i]=[],f=0;f<u;++f)(o=a[f])&&t.call(o,o.__data__,f,a)&&c.push(o);return new po(r,this._parents,this._name,this._id)},merge:function(t){if(t._id!==this._id)throw new Error;for(var n=this._groups,e=t._groups,r=n.length,i=e.length,o=Math.min(r,i),a=new Array(r),u=0;u<o;++u)for(var c,f=n[u],s=e[u],l=f.length,h=a[u]=new Array(l),d=0;d<l;++d)(c=f[d]||s[d])&&(h[d]=c);for(;u<r;++u)a[u]=n[u];return new po(a,this._parents,this._name,this._id)},selection:function(){return new so(this._groups,this._parents)},transition:function(){for(var t=this._name,n=this._id,e=yo(),r=this._groups,i=r.length,o=0;o<i;++o)for(var a,u=r[o],c=u.length,f=0;f<c;++f)if(a=u[f]){var s=Xi(a,n);Li(a,t,e,f,u,{time:s.time+s.delay+s.duration,delay:0,duration:s.duration,ease:s.ease})}return new po(r,this._parents,t,e)},call:vo.call,nodes:vo.nodes,node:vo.node,size:vo.size,empty:vo.empty,each:vo.each,on:function(t,n){var e=this._id;return arguments.length<2?Xi(this.node(),e).on.on(t):this.each(function(t,n,e){var r,i,o=function(t){return(t+"").trim().split(/^|\s+/).every((function(t){var n=t.indexOf(".");return n>=0&&(t=t.slice(0,n)),!t||"start"===t}))}(n)?ji:Hi;return function(){var a=o(this,t),u=a.on;u!==r&&(i=(r=u).copy()).on(n,e),a.on=i}}(e,t,n))},attr:function(t,n){var e=It(t),r="transform"===e?ni:Ki;return this.attrTween(t,"function"==typeof n?(e.local?ro:eo)(e,r,Zi(this,"attr."+t,n)):null==n?(e.local?Ji:Qi)(e):(e.local?no:to)(e,r,n))},attrTween:function(t,n){var e="attr."+t;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==n)return this.tween(e,null);if("function"!=typeof n)throw new Error;var r=It(t);return this.tween(e,(r.local?io:oo)(r,n))},style:function(t,n,e){var r="transform"==(t+="")?ti:Ki;return null==n?this.styleTween(t,function(t,n){var e,r,i;return function(){var o=_n(this,t),a=(this.style.removeProperty(t),_n(this,t));return o===a?null:o===e&&a===r?i:i=n(e=o,r=a)}}(t,r)).on("end.style."+t,lo(t)):"function"==typeof n?this.styleTween(t,function(t,n,e){var r,i,o;return function(){var a=_n(this,t),u=e(this),c=u+"";return null==u&&(this.style.removeProperty(t),c=u=_n(this,t)),a===c?null:a===r&&c===i?o:(i=c,o=n(r=a,u))}}(t,r,Zi(this,"style."+t,n))).each(function(t,n){var e,r,i,o,a="style."+n,u="end."+a;return function(){var c=Hi(this,t),f=c.on,s=null==c.value[a]?o||(o=lo(n)):void 0;f===e&&i===s||(r=(e=f).copy()).on(u,i=s),c.on=r}}(this._id,t)):this.styleTween(t,function(t,n,e){var r,i,o=e+"";return function(){var a=_n(this,t);return a===o?null:a===r?i:i=n(r=a,e)}}(t,r,n),e).on("end.style."+t,null)},styleTween:function(t,n,e){var r="style."+(t+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(null==n)return this.tween(r,null);if("function"!=typeof n)throw new Error;return this.tween(r,function(t,n,e){var r,i;function o(){var o=n.apply(this,arguments);return o!==i&&(r=(i=o)&&function(t,n,e){return function(r){this.style.setProperty(t,n.call(this,r),e)}}(t,o,e)),r}return o._value=n,o}(t,n,null==e?"":e))},text:function(t){return this.tween("text","function"==typeof t?function(t){return function(){var n=t(this);this.textContent=null==n?"":n}}(Zi(this,"text",t)):function(t){return function(){this.textContent=t}}(null==t?"":t+""))},textTween:function(t){var n="text";if(arguments.length<1)return(n=this.tween(n))&&n._value;if(null==t)return this.tween(n,null);if("function"!=typeof t)throw new Error;return this.tween(n,function(t){var n,e;function r(){var r=t.apply(this,arguments);return r!==e&&(n=(e=r)&&function(t){return function(n){this.textContent=t.call(this,n)}}(r)),n}return r._value=t,r}(t))},remove:function(){return this.on("end.remove",function(t){return function(){var n=this.parentNode;for(var e in this.__transition)if(+e!==t)return;n&&n.removeChild(this)}}(this._id))},tween:function(t,n){var e=this._id;if(t+="",arguments.length<2){for(var r,i=Xi(this.node(),e).tween,o=0,a=i.length;o<a;++o)if((r=i[o]).name===t)return r.value;return null}return this.each((null==n?Vi:Wi)(e,t,n))},delay:function(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?ao:uo)(n,t)):Xi(this.node(),n).delay},duration:function(t){var n=this._id;return arguments.length?this.each(("function"==typeof t?co:fo)(n,t)):Xi(this.node(),n).duration},ease:function(t){var n=this._id;return arguments.length?this.each(function(t,n){if("function"!=typeof n)throw new Error;return function(){Hi(this,t).ease=n}}(n,t)):Xi(this.node(),n).ease},easeVarying:function(t){if("function"!=typeof t)throw new Error;return this.each(function(t,n){return function(){var e=n.apply(this,arguments);if("function"!=typeof e)throw new Error;Hi(this,t).ease=e}}(this._id,t))},end:function(){var t,n,e=this,r=e._id,i=e.size();return new Promise((function(o,a){var u={value:a},c={value:function(){0==--i&&o()}};e.each((function(){var e=Hi(this,r),i=e.on;i!==t&&((n=(t=i).copy())._.cancel.push(u),n._.interrupt.push(u),n._.end.push(c)),e.on=n})),0===i&&o()}))},[Symbol.iterator]:vo[Symbol.iterator]};function _o(t){return((t*=2)<=1?t*t:--t*(2-t)+1)/2}function bo(t){return((t*=2)<=1?t*t*t:(t-=2)*t*t+2)/2}var mo=function t(n){function e(t){return Math.pow(t,n)}return n=+n,e.exponent=t,e}(3),xo=function t(n){function e(t){return 1-Math.pow(1-t,n)}return n=+n,e.exponent=t,e}(3),wo=function t(n){function e(t){return((t*=2)<=1?Math.pow(t,n):2-Math.pow(2-t,n))/2}return n=+n,e.exponent=t,e}(3),Mo=Math.PI,To=Mo/2;function Ao(t){return(1-Math.cos(Mo*t))/2}function So(t){return 1.0009775171065494*(Math.pow(2,-10*t)-.0009765625)}function Eo(t){return((t*=2)<=1?So(1-t):2-So(t-1))/2}function No(t){return((t*=2)<=1?1-Math.sqrt(1-t*t):Math.sqrt(1-(t-=2)*t)+1)/2}var ko=4/11,Co=6/11,Po=8/11,zo=3/4,$o=9/11,Do=10/11,Ro=15/16,Fo=21/22,qo=63/64,Uo=1/ko/ko;function Io(t){return(t=+t)<ko?Uo*t*t:t<Po?Uo*(t-=Co)*t+zo:t<Do?Uo*(t-=$o)*t+Ro:Uo*(t-=Fo)*t+qo}var Oo=1.70158,Bo=function t(n){function e(t){return(t=+t)*t*(n*(t-1)+t)}return n=+n,e.overshoot=t,e}(Oo),Yo=function t(n){function e(t){return--t*t*((t+1)*n+t)+1}return n=+n,e.overshoot=t,e}(Oo),Lo=function t(n){function e(t){return((t*=2)<1?t*t*((n+1)*t-n):(t-=2)*t*((n+1)*t+n)+2)/2}return n=+n,e.overshoot=t,e}(Oo),jo=2*Math.PI,Ho=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=jo);function i(t){return n*So(- --t)*Math.sin((r-t)/e)}return i.amplitude=function(n){return t(n,e*jo)},i.period=function(e){return t(n,e)},i}(1,.3),Xo=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=jo);function i(t){return 1-n*So(t=+t)*Math.sin((t+r)/e)}return i.amplitude=function(n){return t(n,e*jo)},i.period=function(e){return t(n,e)},i}(1,.3),Go=function t(n,e){var r=Math.asin(1/(n=Math.max(1,n)))*(e/=jo);function i(t){return((t=2*t-1)<0?n*So(-t)*Math.sin((r-t)/e):2-n*So(t)*Math.sin((r+t)/e))/2}return i.amplitude=function(n){return t(n,e*jo)},i.period=function(e){return t(n,e)},i}(1,.3),Vo={time:null,delay:0,duration:250,ease:bo};function Wo(t,n){for(var e;!(e=t.__transition)||!(e=e[n]);)if(!(t=t.parentNode))throw new Error(`transition ${n} not found`);return e}Wn.prototype.interrupt=function(t){return this.each((function(){Gi(this,t)}))},Wn.prototype.transition=function(t){var n,e;t instanceof po?(n=t._id,t=t._name):(n=yo(),(e=Vo).time=Ai(),t=null==t?null:t+"");for(var r=this._groups,i=r.length,o=0;o<i;++o)for(var a,u=r[o],c=u.length,f=0;f<c;++f)(a=u[f])&&Li(a,t,n,f,u,e||Wo(a,n));return new po(r,this._parents,t,n)};var Zo=[null];var Ko=t=>()=>t;function Qo(t,{sourceEvent:n,target:e,selection:r,mode:i,dispatch:o}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},target:{value:e,enumerable:!0,configurable:!0},selection:{value:r,enumerable:!0,configurable:!0},mode:{value:i,enumerable:!0,configurable:!0},_:{value:o}})}function Jo(t){t.preventDefault(),t.stopImmediatePropagation()}var ta={name:"drag"},na={name:"space"},ea={name:"handle"},ra={name:"center"};const{abs:ia,max:oa,min:aa}=Math;function ua(t){return[+t[0],+t[1]]}function ca(t){return[ua(t[0]),ua(t[1])]}var fa={name:"x",handles:["w","e"].map(va),input:function(t,n){return null==t?null:[[+t[0],n[0][1]],[+t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},sa={name:"y",handles:["n","s"].map(va),input:function(t,n){return null==t?null:[[n[0][0],+t[0]],[n[1][0],+t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},la={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(va),input:function(t){return null==t?null:ca(t)},output:function(t){return t}},ha={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},da={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},pa={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},ga={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},ya={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function va(t){return{type:t}}function _a(t){return!t.ctrlKey&&!t.button}function ba(){var t=this.ownerSVGElement||this;return t.hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function ma(){return navigator.maxTouchPoints||"ontouchstart"in this}function xa(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function wa(t){var n,e=ba,r=_a,i=ma,o=!0,a=$t("start","brush","end"),u=6;function c(n){var e=n.property("__brush",g).selectAll(".overlay").data([va("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",ha.overlay).merge(e).each((function(){var t=xa(this).extent;Zn(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])})),n.selectAll(".selection").data([va("selection")]).enter().append("rect").attr("class","selection").attr("cursor",ha.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var r=n.selectAll(".handle").data(t.handles,(function(t){return t.type}));r.exit().remove(),r.enter().append("rect").attr("class",(function(t){return"handle handle--"+t.type})).attr("cursor",(function(t){return ha[t.type]})),n.each(f).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",h).filter(i).on("touchstart.brush",h).on("touchmove.brush",d).on("touchend.brush touchcancel.brush",p).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function f(){var t=Zn(this),n=xa(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",(function(t){return"e"===t.type[t.type.length-1]?n[1][0]-u/2:n[0][0]-u/2})).attr("y",(function(t){return"s"===t.type[0]?n[1][1]-u/2:n[0][1]-u/2})).attr("width",(function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+u:u})).attr("height",(function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+u:u}))):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function s(t,n,e){var r=t.__brush.emitter;return!r||e&&r.clean?new l(t,n,e):r}function l(t,n,e){this.that=t,this.args=n,this.state=t.__brush,this.active=0,this.clean=e}function h(e){if((!n||e.touches)&&r.apply(this,arguments)){var i,a,u,c,l,h,d,p,g,y,v,_=this,b=e.target.__data__.type,m="selection"===(o&&e.metaKey?b="overlay":b)?ta:o&&e.altKey?ra:ea,x=t===sa?null:ga[b],w=t===fa?null:ya[b],M=xa(_),T=M.extent,A=M.selection,S=T[0][0],E=T[0][1],N=T[1][0],k=T[1][1],C=0,P=0,z=x&&w&&o&&e.shiftKey,$=Array.from(e.touches||[e],(t=>{const n=t.identifier;return(t=ne(t,_)).point0=t.slice(),t.identifier=n,t}));Gi(_);var D=s(_,arguments,!0).beforestart();if("overlay"===b){A&&(g=!0);const n=[$[0],$[1]||$[0]];M.selection=A=[[i=t===sa?S:aa(n[0][0],n[1][0]),u=t===fa?E:aa(n[0][1],n[1][1])],[l=t===sa?N:oa(n[0][0],n[1][0]),d=t===fa?k:oa(n[0][1],n[1][1])]],$.length>1&&I(e)}else i=A[0][0],u=A[0][1],l=A[1][0],d=A[1][1];a=i,c=u,h=l,p=d;var R=Zn(_).attr("pointer-events","none"),F=R.selectAll(".overlay").attr("cursor",ha[b]);if(e.touches)D.moved=U,D.ended=O;else{var q=Zn(e.view).on("mousemove.brush",U,!0).on("mouseup.brush",O,!0);o&&q.on("keydown.brush",(function(t){switch(t.keyCode){case 16:z=x&&w;break;case 18:m===ea&&(x&&(l=h-C*x,i=a+C*x),w&&(d=p-P*w,u=c+P*w),m=ra,I(t));break;case 32:m!==ea&&m!==ra||(x<0?l=h-C:x>0&&(i=a-C),w<0?d=p-P:w>0&&(u=c-P),m=na,F.attr("cursor",ha.selection),I(t));break;default:return}Jo(t)}),!0).on("keyup.brush",(function(t){switch(t.keyCode){case 16:z&&(y=v=z=!1,I(t));break;case 18:m===ra&&(x<0?l=h:x>0&&(i=a),w<0?d=p:w>0&&(u=c),m=ea,I(t));break;case 32:m===na&&(t.altKey?(x&&(l=h-C*x,i=a+C*x),w&&(d=p-P*w,u=c+P*w),m=ra):(x<0?l=h:x>0&&(i=a),w<0?d=p:w>0&&(u=c),m=ea),F.attr("cursor",ha[b]),I(t));break;default:return}Jo(t)}),!0),ae(e.view)}f.call(_),D.start(e,m.name)}function U(t){for(const n of t.changedTouches||[t])for(const t of $)t.identifier===n.identifier&&(t.cur=ne(n,_));if(z&&!y&&!v&&1===$.length){const t=$[0];ia(t.cur[0]-t[0])>ia(t.cur[1]-t[1])?v=!0:y=!0}for(const t of $)t.cur&&(t[0]=t.cur[0],t[1]=t.cur[1]);g=!0,Jo(t),I(t)}function I(t){const n=$[0],e=n.point0;var r;switch(C=n[0]-e[0],P=n[1]-e[1],m){case na:case ta:x&&(C=oa(S-i,aa(N-l,C)),a=i+C,h=l+C),w&&(P=oa(E-u,aa(k-d,P)),c=u+P,p=d+P);break;case ea:$[1]?(x&&(a=oa(S,aa(N,$[0][0])),h=oa(S,aa(N,$[1][0])),x=1),w&&(c=oa(E,aa(k,$[0][1])),p=oa(E,aa(k,$[1][1])),w=1)):(x<0?(C=oa(S-i,aa(N-i,C)),a=i+C,h=l):x>0&&(C=oa(S-l,aa(N-l,C)),a=i,h=l+C),w<0?(P=oa(E-u,aa(k-u,P)),c=u+P,p=d):w>0&&(P=oa(E-d,aa(k-d,P)),c=u,p=d+P));break;case ra:x&&(a=oa(S,aa(N,i-C*x)),h=oa(S,aa(N,l+C*x))),w&&(c=oa(E,aa(k,u-P*w)),p=oa(E,aa(k,d+P*w)))}h<a&&(x*=-1,r=i,i=l,l=r,r=a,a=h,h=r,b in da&&F.attr("cursor",ha[b=da[b]])),p<c&&(w*=-1,r=u,u=d,d=r,r=c,c=p,p=r,b in pa&&F.attr("cursor",ha[b=pa[b]])),M.selection&&(A=M.selection),y&&(a=A[0][0],h=A[1][0]),v&&(c=A[0][1],p=A[1][1]),A[0][0]===a&&A[0][1]===c&&A[1][0]===h&&A[1][1]===p||(M.selection=[[a,c],[h,p]],f.call(_),D.brush(t,m.name))}function O(t){if(function(t){t.stopImmediatePropagation()}(t),t.touches){if(t.touches.length)return;n&&clearTimeout(n),n=setTimeout((function(){n=null}),500)}else ue(t.view,g),q.on("keydown.brush keyup.brush mousemove.brush mouseup.brush",null);R.attr("pointer-events","all"),F.attr("cursor",ha.overlay),M.selection&&(A=M.selection),function(t){return t[0][0]===t[1][0]||t[0][1]===t[1][1]}(A)&&(M.selection=null,f.call(_)),D.end(t,m.name)}}function d(t){s(this,arguments).moved(t)}function p(t){s(this,arguments).ended(t)}function g(){var n=this.__brush||{selection:null};return n.extent=ca(e.apply(this,arguments)),n.dim=t,n}return c.move=function(n,e,r){n.tween?n.on("start.brush",(function(t){s(this,arguments).beforestart().start(t)})).on("interrupt.brush end.brush",(function(t){s(this,arguments).end(t)})).tween("brush",(function(){var n=this,r=n.__brush,i=s(n,arguments),o=r.selection,a=t.input("function"==typeof e?e.apply(this,arguments):e,r.extent),u=Gr(o,a);function c(t){r.selection=1===t&&null===a?null:u(t),f.call(n),i.brush()}return null!==o&&null!==a?c:c(1)})):n.each((function(){var n=this,i=arguments,o=n.__brush,a=t.input("function"==typeof e?e.apply(n,i):e,o.extent),u=s(n,i).beforestart();Gi(n),o.selection=null===a?null:a,f.call(n),u.start(r).brush(r).end(r)}))},c.clear=function(t,n){c.move(t,null,n)},l.prototype={beforestart:function(){return 1==++this.active&&(this.state.emitter=this,this.starting=!0),this},start:function(t,n){return this.starting?(this.starting=!1,this.emit("start",t,n)):this.emit("brush",t),this},brush:function(t,n){return this.emit("brush",t,n),this},end:function(t,n){return 0==--this.active&&(delete this.state.emitter,this.emit("end",t,n)),this},emit:function(n,e,r){var i=Zn(this.that).datum();a.call(n,this.that,new Qo(n,{sourceEvent:e,target:c,selection:t.output(this.state.selection),mode:r,dispatch:a}),i)}},c.extent=function(t){return arguments.length?(e="function"==typeof t?t:Ko(ca(t)),c):e},c.filter=function(t){return arguments.length?(r="function"==typeof t?t:Ko(!!t),c):r},c.touchable=function(t){return arguments.length?(i="function"==typeof t?t:Ko(!!t),c):i},c.handleSize=function(t){return arguments.length?(u=+t,c):u},c.keyModifiers=function(t){return arguments.length?(o=!!t,c):o},c.on=function(){var t=a.on.apply(a,arguments);return t===a?c:t},c}var Ma=Math.abs,Ta=Math.cos,Aa=Math.sin,Sa=Math.PI,Ea=Sa/2,Na=2*Sa,ka=Math.max,Ca=1e-12;function Pa(t,n){return Array.from({length:n-t},((n,e)=>t+e))}function za(t,n){var e=0,r=null,i=null,o=null;function a(a){var u,c=a.length,f=new Array(c),s=Pa(0,c),l=new Array(c*c),h=new Array(c),d=0;a=Float64Array.from({length:c*c},n?(t,n)=>a[n%c][n/c|0]:(t,n)=>a[n/c|0][n%c]);for(let n=0;n<c;++n){let e=0;for(let r=0;r<c;++r)e+=a[n*c+r]+t*a[r*c+n];d+=f[n]=e}u=(d=ka(0,Na-e*c)/d)?e:Na/c;{let n=0;r&&s.sort(((t,n)=>r(f[t],f[n])));for(const e of s){const r=n;if(t){const t=Pa(1+~c,c).filter((t=>t<0?a[~t*c+e]:a[e*c+t]));i&&t.sort(((t,n)=>i(t<0?-a[~t*c+e]:a[e*c+t],n<0?-a[~n*c+e]:a[e*c+n])));for(const r of t)if(r<0){(l[~r*c+e]||(l[~r*c+e]={source:null,target:null})).target={index:e,startAngle:n,endAngle:n+=a[~r*c+e]*d,value:a[~r*c+e]}}else{(l[e*c+r]||(l[e*c+r]={source:null,target:null})).source={index:e,startAngle:n,endAngle:n+=a[e*c+r]*d,value:a[e*c+r]}}h[e]={index:e,startAngle:r,endAngle:n,value:f[e]}}else{const t=Pa(0,c).filter((t=>a[e*c+t]||a[t*c+e]));i&&t.sort(((t,n)=>i(a[e*c+t],a[e*c+n])));for(const r of t){let t;if(e<r?(t=l[e*c+r]||(l[e*c+r]={source:null,target:null}),t.source={index:e,startAngle:n,endAngle:n+=a[e*c+r]*d,value:a[e*c+r]}):(t=l[r*c+e]||(l[r*c+e]={source:null,target:null}),t.target={index:e,startAngle:n,endAngle:n+=a[e*c+r]*d,value:a[e*c+r]},e===r&&(t.source=t.target)),t.source&&t.target&&t.source.value<t.target.value){const n=t.source;t.source=t.target,t.target=n}}h[e]={index:e,startAngle:r,endAngle:n,value:f[e]}}n+=u}}return(l=Object.values(l)).groups=h,o?l.sort(o):l}return a.padAngle=function(t){return arguments.length?(e=ka(0,t),a):e},a.sortGroups=function(t){return arguments.length?(r=t,a):r},a.sortSubgroups=function(t){return arguments.length?(i=t,a):i},a.sortChords=function(t){return arguments.length?(null==t?o=null:(n=t,o=function(t,e){return n(t.source.value+t.target.value,e.source.value+e.target.value)})._=t,a):o&&o._;var n},a}const $a=Math.PI,Da=2*$a,Ra=1e-6,Fa=Da-Ra;function qa(t){this._+=t[0];for(let n=1,e=t.length;n<e;++n)this._+=arguments[n]+t[n]}let Ua=class{constructor(t){this._x0=this._y0=this._x1=this._y1=null,this._="",this._append=null==t?qa:function(t){let n=Math.floor(t);if(!(n>=0))throw new Error(`invalid digits: ${t}`);if(n>15)return qa;const e=10**n;return function(t){this._+=t[0];for(let n=1,r=t.length;n<r;++n)this._+=Math.round(arguments[n]*e)/e+t[n]}}(t)}moveTo(t,n){this._append`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}`}closePath(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._append`Z`)}lineTo(t,n){this._append`L${this._x1=+t},${this._y1=+n}`}quadraticCurveTo(t,n,e,r){this._append`Q${+t},${+n},${this._x1=+e},${this._y1=+r}`}bezierCurveTo(t,n,e,r,i,o){this._append`C${+t},${+n},${+e},${+r},${this._x1=+i},${this._y1=+o}`}arcTo(t,n,e,r,i){if(t=+t,n=+n,e=+e,r=+r,(i=+i)<0)throw new Error(`negative radius: ${i}`);let o=this._x1,a=this._y1,u=e-t,c=r-n,f=o-t,s=a-n,l=f*f+s*s;if(null===this._x1)this._append`M${this._x1=t},${this._y1=n}`;else if(l>Ra)if(Math.abs(s*u-c*f)>Ra&&i){let h=e-o,d=r-a,p=u*u+c*c,g=h*h+d*d,y=Math.sqrt(p),v=Math.sqrt(l),_=i*Math.tan(($a-Math.acos((p+l-g)/(2*y*v)))/2),b=_/v,m=_/y;Math.abs(b-1)>Ra&&this._append`L${t+b*f},${n+b*s}`,this._append`A${i},${i},0,0,${+(s*h>f*d)},${this._x1=t+m*u},${this._y1=n+m*c}`}else this._append`L${this._x1=t},${this._y1=n}`;else;}arc(t,n,e,r,i,o){if(t=+t,n=+n,o=!!o,(e=+e)<0)throw new Error(`negative radius: ${e}`);let a=e*Math.cos(r),u=e*Math.sin(r),c=t+a,f=n+u,s=1^o,l=o?r-i:i-r;null===this._x1?this._append`M${c},${f}`:(Math.abs(this._x1-c)>Ra||Math.abs(this._y1-f)>Ra)&&this._append`L${c},${f}`,e&&(l<0&&(l=l%Da+Da),l>Fa?this._append`A${e},${e},0,1,${s},${t-a},${n-u}A${e},${e},0,1,${s},${this._x1=c},${this._y1=f}`:l>Ra&&this._append`A${e},${e},0,${+(l>=$a)},${s},${this._x1=t+e*Math.cos(i)},${this._y1=n+e*Math.sin(i)}`)}rect(t,n,e,r){this._append`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}h${e=+e}v${+r}h${-e}Z`}toString(){return this._}};function Ia(){return new Ua}Ia.prototype=Ua.prototype;var Oa=Array.prototype.slice;function Ba(t){return function(){return t}}function Ya(t){return t.source}function La(t){return t.target}function ja(t){return t.radius}function Ha(t){return t.startAngle}function Xa(t){return t.endAngle}function Ga(){return 0}function Va(){return 10}function Wa(t){var n=Ya,e=La,r=ja,i=ja,o=Ha,a=Xa,u=Ga,c=null;function f(){var f,s=n.apply(this,arguments),l=e.apply(this,arguments),h=u.apply(this,arguments)/2,d=Oa.call(arguments),p=+r.apply(this,(d[0]=s,d)),g=o.apply(this,d)-Ea,y=a.apply(this,d)-Ea,v=+i.apply(this,(d[0]=l,d)),_=o.apply(this,d)-Ea,b=a.apply(this,d)-Ea;if(c||(c=f=Ia()),h>Ca&&(Ma(y-g)>2*h+Ca?y>g?(g+=h,y-=h):(g-=h,y+=h):g=y=(g+y)/2,Ma(b-_)>2*h+Ca?b>_?(_+=h,b-=h):(_-=h,b+=h):_=b=(_+b)/2),c.moveTo(p*Ta(g),p*Aa(g)),c.arc(0,0,p,g,y),g!==_||y!==b)if(t){var m=v-+t.apply(this,arguments),x=(_+b)/2;c.quadraticCurveTo(0,0,m*Ta(_),m*Aa(_)),c.lineTo(v*Ta(x),v*Aa(x)),c.lineTo(m*Ta(b),m*Aa(b))}else c.quadraticCurveTo(0,0,v*Ta(_),v*Aa(_)),c.arc(0,0,v,_,b);if(c.quadraticCurveTo(0,0,p*Ta(g),p*Aa(g)),c.closePath(),f)return c=null,f+""||null}return t&&(f.headRadius=function(n){return arguments.length?(t="function"==typeof n?n:Ba(+n),f):t}),f.radius=function(t){return arguments.length?(r=i="function"==typeof t?t:Ba(+t),f):r},f.sourceRadius=function(t){return arguments.length?(r="function"==typeof t?t:Ba(+t),f):r},f.targetRadius=function(t){return arguments.length?(i="function"==typeof t?t:Ba(+t),f):i},f.startAngle=function(t){return arguments.length?(o="function"==typeof t?t:Ba(+t),f):o},f.endAngle=function(t){return arguments.length?(a="function"==typeof t?t:Ba(+t),f):a},f.padAngle=function(t){return arguments.length?(u="function"==typeof t?t:Ba(+t),f):u},f.source=function(t){return arguments.length?(n=t,f):n},f.target=function(t){return arguments.length?(e=t,f):e},f.context=function(t){return arguments.length?(c=null==t?null:t,f):c},f}var Za=Array.prototype.slice;function Ka(t,n){return t-n}var Qa=t=>()=>t;function Ja(t,n){for(var e,r=-1,i=n.length;++r<i;)if(e=tu(t,n[r]))return e;return 0}function tu(t,n){for(var e=n[0],r=n[1],i=-1,o=0,a=t.length,u=a-1;o<a;u=o++){var c=t[o],f=c[0],s=c[1],l=t[u],h=l[0],d=l[1];if(nu(c,l,n))return 0;s>r!=d>r&&e<(h-f)*(r-s)/(d-s)+f&&(i=-i)}return i}function nu(t,n,e){var r,i,o,a;return function(t,n,e){return(n[0]-t[0])*(e[1]-t[1])==(e[0]-t[0])*(n[1]-t[1])}(t,n,e)&&(i=t[r=+(t[0]===n[0])],o=e[r],a=n[r],i<=o&&o<=a||a<=o&&o<=i)}function eu(){}var ru=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function iu(){var t=1,n=1,e=K,r=u;function i(t){var n=e(t);if(Array.isArray(n))n=n.slice().sort(Ka);else{const e=M(t,ou);for(n=G(...Z(e[0],e[1],n),n);n[n.length-1]>=e[1];)n.pop();for(;n[1]<e[0];)n.shift()}return n.map((n=>o(t,n)))}function o(e,i){const o=null==i?NaN:+i;if(isNaN(o))throw new Error(`invalid value: ${i}`);var u=[],c=[];return function(e,r,i){var o,u,c,f,s,l,h=new Array,d=new Array;o=u=-1,f=au(e[0],r),ru[f<<1].forEach(p);for(;++o<t-1;)c=f,f=au(e[o+1],r),ru[c|f<<1].forEach(p);ru[f|0].forEach(p);for(;++u<n-1;){for(o=-1,f=au(e[u*t+t],r),s=au(e[u*t],r),ru[f<<1|s<<2].forEach(p);++o<t-1;)c=f,f=au(e[u*t+t+o+1],r),l=s,s=au(e[u*t+o+1],r),ru[c|f<<1|s<<2|l<<3].forEach(p);ru[f|s<<3].forEach(p)}o=-1,s=e[u*t]>=r,ru[s<<2].forEach(p);for(;++o<t-1;)l=s,s=au(e[u*t+o+1],r),ru[s<<2|l<<3].forEach(p);function p(t){var n,e,r=[t[0][0]+o,t[0][1]+u],c=[t[1][0]+o,t[1][1]+u],f=a(r),s=a(c);(n=d[f])?(e=h[s])?(delete d[n.end],delete h[e.start],n===e?(n.ring.push(c),i(n.ring)):h[n.start]=d[e.end]={start:n.start,end:e.end,ring:n.ring.concat(e.ring)}):(delete d[n.end],n.ring.push(c),d[n.end=s]=n):(n=h[s])?(e=d[f])?(delete h[n.start],delete d[e.end],n===e?(n.ring.push(c),i(n.ring)):h[e.start]=d[n.end]={start:e.start,end:n.end,ring:e.ring.concat(n.ring)}):(delete h[n.start],n.ring.unshift(r),h[n.start=f]=n):h[f]=d[s]={start:f,end:s,ring:[r,c]}}ru[s<<3].forEach(p)}(e,o,(function(t){r(t,e,o),function(t){for(var n=0,e=t.length,r=t[e-1][1]*t[0][0]-t[e-1][0]*t[0][1];++n<e;)r+=t[n-1][1]*t[n][0]-t[n-1][0]*t[n][1];return r}(t)>0?u.push([t]):c.push(t)})),c.forEach((function(t){for(var n,e=0,r=u.length;e<r;++e)if(-1!==Ja((n=u[e])[0],t))return void n.push(t)})),{type:"MultiPolygon",value:i,coordinates:u}}function a(n){return 2*n[0]+n[1]*(t+1)*4}function u(e,r,i){e.forEach((function(e){var o=e[0],a=e[1],u=0|o,c=0|a,f=uu(r[c*t+u]);o>0&&o<t&&u===o&&(e[0]=cu(o,uu(r[c*t+u-1]),f,i)),a>0&&a<n&&c===a&&(e[1]=cu(a,uu(r[(c-1)*t+u]),f,i))}))}return i.contour=o,i.size=function(e){if(!arguments.length)return[t,n];var r=Math.floor(e[0]),o=Math.floor(e[1]);if(!(r>=0&&o>=0))throw new Error("invalid size");return t=r,n=o,i},i.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?Qa(Za.call(t)):Qa(t),i):e},i.smooth=function(t){return arguments.length?(r=t?u:eu,i):r===u},i}function ou(t){return isFinite(t)?t:NaN}function au(t,n){return null!=t&&+t>=n}function uu(t){return null==t||isNaN(t=+t)?-1/0:t}function cu(t,n,e,r){const i=r-n,o=e-n,a=isFinite(i)||isFinite(o)?i/o:Math.sign(i)/Math.sign(o);return isNaN(a)?t:t+a-.5}function fu(t){return t[0]}function su(t){return t[1]}function lu(){return 1}const hu=134217729,du=33306690738754706e-32;function pu(t,n,e,r,i){let o,a,u,c,f=n[0],s=r[0],l=0,h=0;s>f==s>-f?(o=f,f=n[++l]):(o=s,s=r[++h]);let d=0;if(l<t&&h<e)for(s>f==s>-f?(a=f+o,u=o-(a-f),f=n[++l]):(a=s+o,u=o-(a-s),s=r[++h]),o=a,0!==u&&(i[d++]=u);l<t&&h<e;)s>f==s>-f?(a=o+f,c=a-o,u=o-(a-c)+(f-c),f=n[++l]):(a=o+s,c=a-o,u=o-(a-c)+(s-c),s=r[++h]),o=a,0!==u&&(i[d++]=u);for(;l<t;)a=o+f,c=a-o,u=o-(a-c)+(f-c),f=n[++l],o=a,0!==u&&(i[d++]=u);for(;h<e;)a=o+s,c=a-o,u=o-(a-c)+(s-c),s=r[++h],o=a,0!==u&&(i[d++]=u);return 0===o&&0!==d||(i[d++]=o),d}function gu(t){return new Float64Array(t)}const yu=22204460492503146e-32,vu=11093356479670487e-47,_u=gu(4),bu=gu(8),mu=gu(12),xu=gu(16),wu=gu(4);function Mu(t,n,e,r,i,o){const a=(n-o)*(e-i),u=(t-i)*(r-o),c=a-u,f=Math.abs(a+u);return Math.abs(c)>=33306690738754716e-32*f?c:-function(t,n,e,r,i,o,a){let u,c,f,s,l,h,d,p,g,y,v,_,b,m,x,w,M,T;const A=t-i,S=e-i,E=n-o,N=r-o;m=A*N,h=hu*A,d=h-(h-A),p=A-d,h=hu*N,g=h-(h-N),y=N-g,x=p*y-(m-d*g-p*g-d*y),w=E*S,h=hu*E,d=h-(h-E),p=E-d,h=hu*S,g=h-(h-S),y=S-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,_u[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,_u[1]=b-(v+l)+(l-w),T=_+v,l=T-_,_u[2]=_-(T-l)+(v-l),_u[3]=T;let k=function(t,n){let e=n[0];for(let r=1;r<t;r++)e+=n[r];return e}(4,_u),C=yu*a;if(k>=C||-k>=C)return k;if(l=t-A,u=t-(A+l)+(l-i),l=e-S,f=e-(S+l)+(l-i),l=n-E,c=n-(E+l)+(l-o),l=r-N,s=r-(N+l)+(l-o),0===u&&0===c&&0===f&&0===s)return k;if(C=vu*a+du*Math.abs(k),k+=A*s+N*u-(E*f+S*c),k>=C||-k>=C)return k;m=u*N,h=hu*u,d=h-(h-u),p=u-d,h=hu*N,g=h-(h-N),y=N-g,x=p*y-(m-d*g-p*g-d*y),w=c*S,h=hu*c,d=h-(h-c),p=c-d,h=hu*S,g=h-(h-S),y=S-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,wu[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,wu[1]=b-(v+l)+(l-w),T=_+v,l=T-_,wu[2]=_-(T-l)+(v-l),wu[3]=T;const P=pu(4,_u,4,wu,bu);m=A*s,h=hu*A,d=h-(h-A),p=A-d,h=hu*s,g=h-(h-s),y=s-g,x=p*y-(m-d*g-p*g-d*y),w=E*f,h=hu*E,d=h-(h-E),p=E-d,h=hu*f,g=h-(h-f),y=f-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,wu[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,wu[1]=b-(v+l)+(l-w),T=_+v,l=T-_,wu[2]=_-(T-l)+(v-l),wu[3]=T;const z=pu(P,bu,4,wu,mu);m=u*s,h=hu*u,d=h-(h-u),p=u-d,h=hu*s,g=h-(h-s),y=s-g,x=p*y-(m-d*g-p*g-d*y),w=c*f,h=hu*c,d=h-(h-c),p=c-d,h=hu*f,g=h-(h-f),y=f-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,wu[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,wu[1]=b-(v+l)+(l-w),T=_+v,l=T-_,wu[2]=_-(T-l)+(v-l),wu[3]=T;const $=pu(z,mu,4,wu,xu);return xu[$-1]}(t,n,e,r,i,o,f)}const Tu=Math.pow(2,-52),Au=new Uint32Array(512);class Su{static from(t,n=zu,e=$u){const r=t.length,i=new Float64Array(2*r);for(let o=0;o<r;o++){const r=t[o];i[2*o]=n(r),i[2*o+1]=e(r)}return new Su(i)}constructor(t){const n=t.length>>1;if(n>0&&"number"!=typeof t[0])throw new Error("Expected coords to contain numbers.");this.coords=t;const e=Math.max(2*n-5,0);this._triangles=new Uint32Array(3*e),this._halfedges=new Int32Array(3*e),this._hashSize=Math.ceil(Math.sqrt(n)),this._hullPrev=new Uint32Array(n),this._hullNext=new Uint32Array(n),this._hullTri=new Uint32Array(n),this._hullHash=new Int32Array(this._hashSize),this._ids=new Uint32Array(n),this._dists=new Float64Array(n),this.update()}update(){const{coords:t,_hullPrev:n,_hullNext:e,_hullTri:r,_hullHash:i}=this,o=t.length>>1;let a=1/0,u=1/0,c=-1/0,f=-1/0;for(let n=0;n<o;n++){const e=t[2*n],r=t[2*n+1];e<a&&(a=e),r<u&&(u=r),e>c&&(c=e),r>f&&(f=r),this._ids[n]=n}const s=(a+c)/2,l=(u+f)/2;let h,d,p;for(let n=0,e=1/0;n<o;n++){const r=Eu(s,l,t[2*n],t[2*n+1]);r<e&&(h=n,e=r)}const g=t[2*h],y=t[2*h+1];for(let n=0,e=1/0;n<o;n++){if(n===h)continue;const r=Eu(g,y,t[2*n],t[2*n+1]);r<e&&r>0&&(d=n,e=r)}let v=t[2*d],_=t[2*d+1],b=1/0;for(let n=0;n<o;n++){if(n===h||n===d)continue;const e=ku(g,y,v,_,t[2*n],t[2*n+1]);e<b&&(p=n,b=e)}let m=t[2*p],x=t[2*p+1];if(b===1/0){for(let n=0;n<o;n++)this._dists[n]=t[2*n]-t[0]||t[2*n+1]-t[1];Cu(this._ids,this._dists,0,o-1);const n=new Uint32Array(o);let e=0;for(let t=0,r=-1/0;t<o;t++){const i=this._ids[t],o=this._dists[i];o>r&&(n[e++]=i,r=o)}return this.hull=n.subarray(0,e),this.triangles=new Uint32Array(0),void(this.halfedges=new Uint32Array(0))}if(Mu(g,y,v,_,m,x)<0){const t=d,n=v,e=_;d=p,v=m,_=x,p=t,m=n,x=e}const w=function(t,n,e,r,i,o){const a=e-t,u=r-n,c=i-t,f=o-n,s=a*a+u*u,l=c*c+f*f,h=.5/(a*f-u*c),d=t+(f*s-u*l)*h,p=n+(a*l-c*s)*h;return{x:d,y:p}}(g,y,v,_,m,x);this._cx=w.x,this._cy=w.y;for(let n=0;n<o;n++)this._dists[n]=Eu(t[2*n],t[2*n+1],w.x,w.y);Cu(this._ids,this._dists,0,o-1),this._hullStart=h;let M=3;e[h]=n[p]=d,e[d]=n[h]=p,e[p]=n[d]=h,r[h]=0,r[d]=1,r[p]=2,i.fill(-1),i[this._hashKey(g,y)]=h,i[this._hashKey(v,_)]=d,i[this._hashKey(m,x)]=p,this.trianglesLen=0,this._addTriangle(h,d,p,-1,-1,-1);for(let o,a,u=0;u<this._ids.length;u++){const c=this._ids[u],f=t[2*c],s=t[2*c+1];if(u>0&&Math.abs(f-o)<=Tu&&Math.abs(s-a)<=Tu)continue;if(o=f,a=s,c===h||c===d||c===p)continue;let l=0;for(let t=0,n=this._hashKey(f,s);t<this._hashSize&&(l=i[(n+t)%this._hashSize],-1===l||l===e[l]);t++);l=n[l];let g,y=l;for(;g=e[y],Mu(f,s,t[2*y],t[2*y+1],t[2*g],t[2*g+1])>=0;)if(y=g,y===l){y=-1;break}if(-1===y)continue;let v=this._addTriangle(y,c,e[y],-1,-1,r[y]);r[c]=this._legalize(v+2),r[y]=v,M++;let _=e[y];for(;g=e[_],Mu(f,s,t[2*_],t[2*_+1],t[2*g],t[2*g+1])<0;)v=this._addTriangle(_,c,g,r[c],-1,r[_]),r[c]=this._legalize(v+2),e[_]=_,M--,_=g;if(y===l)for(;g=n[y],Mu(f,s,t[2*g],t[2*g+1],t[2*y],t[2*y+1])<0;)v=this._addTriangle(g,c,y,-1,r[y],r[g]),this._legalize(v+2),r[g]=v,e[y]=y,M--,y=g;this._hullStart=n[c]=y,e[y]=n[_]=c,e[c]=_,i[this._hashKey(f,s)]=c,i[this._hashKey(t[2*y],t[2*y+1])]=y}this.hull=new Uint32Array(M);for(let t=0,n=this._hullStart;t<M;t++)this.hull[t]=n,n=e[n];this.triangles=this._triangles.subarray(0,this.trianglesLen),this.halfedges=this._halfedges.subarray(0,this.trianglesLen)}_hashKey(t,n){return Math.floor(function(t,n){const e=t/(Math.abs(t)+Math.abs(n));return(n>0?3-e:1+e)/4}(t-this._cx,n-this._cy)*this._hashSize)%this._hashSize}_legalize(t){const{_triangles:n,_halfedges:e,coords:r}=this;let i=0,o=0;for(;;){const a=e[t],u=t-t%3;if(o=u+(t+2)%3,-1===a){if(0===i)break;t=Au[--i];continue}const c=a-a%3,f=u+(t+1)%3,s=c+(a+2)%3,l=n[o],h=n[t],d=n[f],p=n[s];if(Nu(r[2*l],r[2*l+1],r[2*h],r[2*h+1],r[2*d],r[2*d+1],r[2*p],r[2*p+1])){n[t]=p,n[a]=l;const r=e[s];if(-1===r){let n=this._hullStart;do{if(this._hullTri[n]===s){this._hullTri[n]=t;break}n=this._hullPrev[n]}while(n!==this._hullStart)}this._link(t,r),this._link(a,e[o]),this._link(o,s);const u=c+(a+1)%3;i<Au.length&&(Au[i++]=u)}else{if(0===i)break;t=Au[--i]}}return o}_link(t,n){this._halfedges[t]=n,-1!==n&&(this._halfedges[n]=t)}_addTriangle(t,n,e,r,i,o){const a=this.trianglesLen;return this._triangles[a]=t,this._triangles[a+1]=n,this._triangles[a+2]=e,this._link(a,r),this._link(a+1,i),this._link(a+2,o),this.trianglesLen+=3,a}}function Eu(t,n,e,r){const i=t-e,o=n-r;return i*i+o*o}function Nu(t,n,e,r,i,o,a,u){const c=t-a,f=n-u,s=e-a,l=r-u,h=i-a,d=o-u,p=s*s+l*l,g=h*h+d*d;return c*(l*g-p*d)-f*(s*g-p*h)+(c*c+f*f)*(s*d-l*h)<0}function ku(t,n,e,r,i,o){const a=e-t,u=r-n,c=i-t,f=o-n,s=a*a+u*u,l=c*c+f*f,h=.5/(a*f-u*c),d=(f*s-u*l)*h,p=(a*l-c*s)*h;return d*d+p*p}function Cu(t,n,e,r){if(r-e<=20)for(let i=e+1;i<=r;i++){const r=t[i],o=n[r];let a=i-1;for(;a>=e&&n[t[a]]>o;)t[a+1]=t[a--];t[a+1]=r}else{let i=e+1,o=r;Pu(t,e+r>>1,i),n[t[e]]>n[t[r]]&&Pu(t,e,r),n[t[i]]>n[t[r]]&&Pu(t,i,r),n[t[e]]>n[t[i]]&&Pu(t,e,i);const a=t[i],u=n[a];for(;;){do{i++}while(n[t[i]]<u);do{o--}while(n[t[o]]>u);if(o<i)break;Pu(t,i,o)}t[e+1]=t[o],t[o]=a,r-i+1>=o-e?(Cu(t,n,i,r),Cu(t,n,e,o-1)):(Cu(t,n,e,o-1),Cu(t,n,i,r))}}function Pu(t,n,e){const r=t[n];t[n]=t[e],t[e]=r}function zu(t){return t[0]}function $u(t){return t[1]}const Du=1e-6;class Ru{constructor(){this._x0=this._y0=this._x1=this._y1=null,this._=""}moveTo(t,n){this._+=`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}`}closePath(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")}lineTo(t,n){this._+=`L${this._x1=+t},${this._y1=+n}`}arc(t,n,e){const r=(t=+t)+(e=+e),i=n=+n;if(e<0)throw new Error("negative radius");null===this._x1?this._+=`M${r},${i}`:(Math.abs(this._x1-r)>Du||Math.abs(this._y1-i)>Du)&&(this._+="L"+r+","+i),e&&(this._+=`A${e},${e},0,1,1,${t-e},${n}A${e},${e},0,1,1,${this._x1=r},${this._y1=i}`)}rect(t,n,e,r){this._+=`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}h${+e}v${+r}h${-e}Z`}value(){return this._||null}}class Fu{constructor(){this._=[]}moveTo(t,n){this._.push([t,n])}closePath(){this._.push(this._[0].slice())}lineTo(t,n){this._.push([t,n])}value(){return this._.length?this._:null}}class qu{constructor(t,[n,e,r,i]=[0,0,960,500]){if(!((r=+r)>=(n=+n)&&(i=+i)>=(e=+e)))throw new Error("invalid bounds");this.delaunay=t,this._circumcenters=new Float64Array(2*t.points.length),this.vectors=new Float64Array(2*t.points.length),this.xmax=r,this.xmin=n,this.ymax=i,this.ymin=e,this._init()}update(){return this.delaunay.update(),this._init(),this}_init(){const{delaunay:{points:t,hull:n,triangles:e},vectors:r}=this;let i,o;const a=this.circumcenters=this._circumcenters.subarray(0,e.length/3*2);for(let r,u,c=0,f=0,s=e.length;c<s;c+=3,f+=2){const s=2*e[c],l=2*e[c+1],h=2*e[c+2],d=t[s],p=t[s+1],g=t[l],y=t[l+1],v=t[h],_=t[h+1],b=g-d,m=y-p,x=v-d,w=_-p,M=2*(b*w-m*x);if(Math.abs(M)<1e-9){if(void 0===i){i=o=0;for(const e of n)i+=t[2*e],o+=t[2*e+1];i/=n.length,o/=n.length}const e=1e9*Math.sign((i-d)*w-(o-p)*x);r=(d+v)/2-e*w,u=(p+_)/2+e*x}else{const t=1/M,n=b*b+m*m,e=x*x+w*w;r=d+(w*n-m*e)*t,u=p+(b*e-x*n)*t}a[f]=r,a[f+1]=u}let u,c,f,s=n[n.length-1],l=4*s,h=t[2*s],d=t[2*s+1];r.fill(0);for(let e=0;e<n.length;++e)s=n[e],u=l,c=h,f=d,l=4*s,h=t[2*s],d=t[2*s+1],r[u+2]=r[l]=f-d,r[u+3]=r[l+1]=h-c}render(t){const n=null==t?t=new Ru:void 0,{delaunay:{halfedges:e,inedges:r,hull:i},circumcenters:o,vectors:a}=this;if(i.length<=1)return null;for(let n=0,r=e.length;n<r;++n){const r=e[n];if(r<n)continue;const i=2*Math.floor(n/3),a=2*Math.floor(r/3),u=o[i],c=o[i+1],f=o[a],s=o[a+1];this._renderSegment(u,c,f,s,t)}let u,c=i[i.length-1];for(let n=0;n<i.length;++n){u=c,c=i[n];const e=2*Math.floor(r[c]/3),f=o[e],s=o[e+1],l=4*u,h=this._project(f,s,a[l+2],a[l+3]);h&&this._renderSegment(f,s,h[0],h[1],t)}return n&&n.value()}renderBounds(t){const n=null==t?t=new Ru:void 0;return t.rect(this.xmin,this.ymin,this.xmax-this.xmin,this.ymax-this.ymin),n&&n.value()}renderCell(t,n){const e=null==n?n=new Ru:void 0,r=this._clip(t);if(null===r||!r.length)return;n.moveTo(r[0],r[1]);let i=r.length;for(;r[0]===r[i-2]&&r[1]===r[i-1]&&i>1;)i-=2;for(let t=2;t<i;t+=2)r[t]===r[t-2]&&r[t+1]===r[t-1]||n.lineTo(r[t],r[t+1]);return n.closePath(),e&&e.value()}*cellPolygons(){const{delaunay:{points:t}}=this;for(let n=0,e=t.length/2;n<e;++n){const t=this.cellPolygon(n);t&&(t.index=n,yield t)}}cellPolygon(t){const n=new Fu;return this.renderCell(t,n),n.value()}_renderSegment(t,n,e,r,i){let o;const a=this._regioncode(t,n),u=this._regioncode(e,r);0===a&&0===u?(i.moveTo(t,n),i.lineTo(e,r)):(o=this._clipSegment(t,n,e,r,a,u))&&(i.moveTo(o[0],o[1]),i.lineTo(o[2],o[3]))}contains(t,n,e){return(n=+n)==n&&(e=+e)==e&&this.delaunay._step(t,n,e)===t}*neighbors(t){const n=this._clip(t);if(n)for(const e of this.delaunay.neighbors(t)){const t=this._clip(e);if(t)t:for(let r=0,i=n.length;r<i;r+=2)for(let o=0,a=t.length;o<a;o+=2)if(n[r]===t[o]&&n[r+1]===t[o+1]&&n[(r+2)%i]===t[(o+a-2)%a]&&n[(r+3)%i]===t[(o+a-1)%a]){yield e;break t}}}_cell(t){const{circumcenters:n,delaunay:{inedges:e,halfedges:r,triangles:i}}=this,o=e[t];if(-1===o)return null;const a=[];let u=o;do{const e=Math.floor(u/3);if(a.push(n[2*e],n[2*e+1]),u=u%3==2?u-2:u+1,i[u]!==t)break;u=r[u]}while(u!==o&&-1!==u);return a}_clip(t){if(0===t&&1===this.delaunay.hull.length)return[this.xmax,this.ymin,this.xmax,this.ymax,this.xmin,this.ymax,this.xmin,this.ymin];const n=this._cell(t);if(null===n)return null;const{vectors:e}=this,r=4*t;return this._simplify(e[r]||e[r+1]?this._clipInfinite(t,n,e[r],e[r+1],e[r+2],e[r+3]):this._clipFinite(t,n))}_clipFinite(t,n){const e=n.length;let r,i,o,a,u=null,c=n[e-2],f=n[e-1],s=this._regioncode(c,f),l=0;for(let h=0;h<e;h+=2)if(r=c,i=f,c=n[h],f=n[h+1],o=s,s=this._regioncode(c,f),0===o&&0===s)a=l,l=0,u?u.push(c,f):u=[c,f];else{let n,e,h,d,p;if(0===o){if(null===(n=this._clipSegment(r,i,c,f,o,s)))continue;[e,h,d,p]=n}else{if(null===(n=this._clipSegment(c,f,r,i,s,o)))continue;[d,p,e,h]=n,a=l,l=this._edgecode(e,h),a&&l&&this._edge(t,a,l,u,u.length),u?u.push(e,h):u=[e,h]}a=l,l=this._edgecode(d,p),a&&l&&this._edge(t,a,l,u,u.length),u?u.push(d,p):u=[d,p]}if(u)a=l,l=this._edgecode(u[0],u[1]),a&&l&&this._edge(t,a,l,u,u.length);else if(this.contains(t,(this.xmin+this.xmax)/2,(this.ymin+this.ymax)/2))return[this.xmax,this.ymin,this.xmax,this.ymax,this.xmin,this.ymax,this.xmin,this.ymin];return u}_clipSegment(t,n,e,r,i,o){const a=i<o;for(a&&([t,n,e,r,i,o]=[e,r,t,n,o,i]);;){if(0===i&&0===o)return a?[e,r,t,n]:[t,n,e,r];if(i&o)return null;let u,c,f=i||o;8&f?(u=t+(e-t)*(this.ymax-n)/(r-n),c=this.ymax):4&f?(u=t+(e-t)*(this.ymin-n)/(r-n),c=this.ymin):2&f?(c=n+(r-n)*(this.xmax-t)/(e-t),u=this.xmax):(c=n+(r-n)*(this.xmin-t)/(e-t),u=this.xmin),i?(t=u,n=c,i=this._regioncode(t,n)):(e=u,r=c,o=this._regioncode(e,r))}}_clipInfinite(t,n,e,r,i,o){let a,u=Array.from(n);if((a=this._project(u[0],u[1],e,r))&&u.unshift(a[0],a[1]),(a=this._project(u[u.length-2],u[u.length-1],i,o))&&u.push(a[0],a[1]),u=this._clipFinite(t,u))for(let n,e=0,r=u.length,i=this._edgecode(u[r-2],u[r-1]);e<r;e+=2)n=i,i=this._edgecode(u[e],u[e+1]),n&&i&&(e=this._edge(t,n,i,u,e),r=u.length);else this.contains(t,(this.xmin+this.xmax)/2,(this.ymin+this.ymax)/2)&&(u=[this.xmin,this.ymin,this.xmax,this.ymin,this.xmax,this.ymax,this.xmin,this.ymax]);return u}_edge(t,n,e,r,i){for(;n!==e;){let e,o;switch(n){case 5:n=4;continue;case 4:n=6,e=this.xmax,o=this.ymin;break;case 6:n=2;continue;case 2:n=10,e=this.xmax,o=this.ymax;break;case 10:n=8;continue;case 8:n=9,e=this.xmin,o=this.ymax;break;case 9:n=1;continue;case 1:n=5,e=this.xmin,o=this.ymin}r[i]===e&&r[i+1]===o||!this.contains(t,e,o)||(r.splice(i,0,e,o),i+=2)}return i}_project(t,n,e,r){let i,o,a,u=1/0;if(r<0){if(n<=this.ymin)return null;(i=(this.ymin-n)/r)<u&&(a=this.ymin,o=t+(u=i)*e)}else if(r>0){if(n>=this.ymax)return null;(i=(this.ymax-n)/r)<u&&(a=this.ymax,o=t+(u=i)*e)}if(e>0){if(t>=this.xmax)return null;(i=(this.xmax-t)/e)<u&&(o=this.xmax,a=n+(u=i)*r)}else if(e<0){if(t<=this.xmin)return null;(i=(this.xmin-t)/e)<u&&(o=this.xmin,a=n+(u=i)*r)}return[o,a]}_edgecode(t,n){return(t===this.xmin?1:t===this.xmax?2:0)|(n===this.ymin?4:n===this.ymax?8:0)}_regioncode(t,n){return(t<this.xmin?1:t>this.xmax?2:0)|(n<this.ymin?4:n>this.ymax?8:0)}_simplify(t){if(t&&t.length>4){for(let n=0;n<t.length;n+=2){const e=(n+2)%t.length,r=(n+4)%t.length;(t[n]===t[e]&&t[e]===t[r]||t[n+1]===t[e+1]&&t[e+1]===t[r+1])&&(t.splice(e,2),n-=2)}t.length||(t=null)}return t}}const Uu=2*Math.PI,Iu=Math.pow;function Ou(t){return t[0]}function Bu(t){return t[1]}function Yu(t,n,e){return[t+Math.sin(t+n)*e,n+Math.cos(t-n)*e]}class Lu{static from(t,n=Ou,e=Bu,r){return new Lu("length"in t?function(t,n,e,r){const i=t.length,o=new Float64Array(2*i);for(let a=0;a<i;++a){const i=t[a];o[2*a]=n.call(r,i,a,t),o[2*a+1]=e.call(r,i,a,t)}return o}(t,n,e,r):Float64Array.from(function*(t,n,e,r){let i=0;for(const o of t)yield n.call(r,o,i,t),yield e.call(r,o,i,t),++i}(t,n,e,r)))}constructor(t){this._delaunator=new Su(t),this.inedges=new Int32Array(t.length/2),this._hullIndex=new Int32Array(t.length/2),this.points=this._delaunator.coords,this._init()}update(){return this._delaunator.update(),this._init(),this}_init(){const t=this._delaunator,n=this.points;if(t.hull&&t.hull.length>2&&function(t){const{triangles:n,coords:e}=t;for(let t=0;t<n.length;t+=3){const r=2*n[t],i=2*n[t+1],o=2*n[t+2];if((e[o]-e[r])*(e[i+1]-e[r+1])-(e[i]-e[r])*(e[o+1]-e[r+1])>1e-10)return!1}return!0}(t)){this.collinear=Int32Array.from({length:n.length/2},((t,n)=>n)).sort(((t,e)=>n[2*t]-n[2*e]||n[2*t+1]-n[2*e+1]));const t=this.collinear[0],e=this.collinear[this.collinear.length-1],r=[n[2*t],n[2*t+1],n[2*e],n[2*e+1]],i=1e-8*Math.hypot(r[3]-r[1],r[2]-r[0]);for(let t=0,e=n.length/2;t<e;++t){const e=Yu(n[2*t],n[2*t+1],i);n[2*t]=e[0],n[2*t+1]=e[1]}this._delaunator=new Su(n)}else delete this.collinear;const e=this.halfedges=this._delaunator.halfedges,r=this.hull=this._delaunator.hull,i=this.triangles=this._delaunator.triangles,o=this.inedges.fill(-1),a=this._hullIndex.fill(-1);for(let t=0,n=e.length;t<n;++t){const n=i[t%3==2?t-2:t+1];-1!==e[t]&&-1!==o[n]||(o[n]=t)}for(let t=0,n=r.length;t<n;++t)a[r[t]]=t;r.length<=2&&r.length>0&&(this.triangles=new Int32Array(3).fill(-1),this.halfedges=new Int32Array(3).fill(-1),this.triangles[0]=r[0],o[r[0]]=1,2===r.length&&(o[r[1]]=0,this.triangles[1]=r[1],this.triangles[2]=r[1]))}voronoi(t){return new qu(this,t)}*neighbors(t){const{inedges:n,hull:e,_hullIndex:r,halfedges:i,triangles:o,collinear:a}=this;if(a){const n=a.indexOf(t);return n>0&&(yield a[n-1]),void(n<a.length-1&&(yield a[n+1]))}const u=n[t];if(-1===u)return;let c=u,f=-1;do{if(yield f=o[c],c=c%3==2?c-2:c+1,o[c]!==t)return;if(c=i[c],-1===c){const n=e[(r[t]+1)%e.length];return void(n!==f&&(yield n))}}while(c!==u)}find(t,n,e=0){if((t=+t)!=t||(n=+n)!=n)return-1;const r=e;let i;for(;(i=this._step(e,t,n))>=0&&i!==e&&i!==r;)e=i;return i}_step(t,n,e){const{inedges:r,hull:i,_hullIndex:o,halfedges:a,triangles:u,points:c}=this;if(-1===r[t]||!c.length)return(t+1)%(c.length>>1);let f=t,s=Iu(n-c[2*t],2)+Iu(e-c[2*t+1],2);const l=r[t];let h=l;do{let r=u[h];const l=Iu(n-c[2*r],2)+Iu(e-c[2*r+1],2);if(l<s&&(s=l,f=r),h=h%3==2?h-2:h+1,u[h]!==t)break;if(h=a[h],-1===h){if(h=i[(o[t]+1)%i.length],h!==r&&Iu(n-c[2*h],2)+Iu(e-c[2*h+1],2)<s)return h;break}}while(h!==l);return f}render(t){const n=null==t?t=new Ru:void 0,{points:e,halfedges:r,triangles:i}=this;for(let n=0,o=r.length;n<o;++n){const o=r[n];if(o<n)continue;const a=2*i[n],u=2*i[o];t.moveTo(e[a],e[a+1]),t.lineTo(e[u],e[u+1])}return this.renderHull(t),n&&n.value()}renderPoints(t,n){void 0!==n||t&&"function"==typeof t.moveTo||(n=t,t=null),n=null==n?2:+n;const e=null==t?t=new Ru:void 0,{points:r}=this;for(let e=0,i=r.length;e<i;e+=2){const i=r[e],o=r[e+1];t.moveTo(i+n,o),t.arc(i,o,n,0,Uu)}return e&&e.value()}renderHull(t){const n=null==t?t=new Ru:void 0,{hull:e,points:r}=this,i=2*e[0],o=e.length;t.moveTo(r[i],r[i+1]);for(let n=1;n<o;++n){const i=2*e[n];t.lineTo(r[i],r[i+1])}return t.closePath(),n&&n.value()}hullPolygon(){const t=new Fu;return this.renderHull(t),t.value()}renderTriangle(t,n){const e=null==n?n=new Ru:void 0,{points:r,triangles:i}=this,o=2*i[t*=3],a=2*i[t+1],u=2*i[t+2];return n.moveTo(r[o],r[o+1]),n.lineTo(r[a],r[a+1]),n.lineTo(r[u],r[u+1]),n.closePath(),e&&e.value()}*trianglePolygons(){const{triangles:t}=this;for(let n=0,e=t.length/3;n<e;++n)yield this.trianglePolygon(n)}trianglePolygon(t){const n=new Fu;return this.renderTriangle(t,n),n.value()}}var ju={},Hu={},Xu=34,Gu=10,Vu=13;function Wu(t){return new Function("d","return {"+t.map((function(t,n){return JSON.stringify(t)+": d["+n+'] || ""'})).join(",")+"}")}function Zu(t){var n=Object.create(null),e=[];return t.forEach((function(t){for(var r in t)r in n||e.push(n[r]=r)})),e}function Ku(t,n){var e=t+"",r=e.length;return r<n?new Array(n-r+1).join(0)+e:e}function Qu(t){var n,e=t.getUTCHours(),r=t.getUTCMinutes(),i=t.getUTCSeconds(),o=t.getUTCMilliseconds();return isNaN(t)?"Invalid Date":((n=t.getUTCFullYear())<0?"-"+Ku(-n,6):n>9999?"+"+Ku(n,6):Ku(n,4))+"-"+Ku(t.getUTCMonth()+1,2)+"-"+Ku(t.getUTCDate(),2)+(o?"T"+Ku(e,2)+":"+Ku(r,2)+":"+Ku(i,2)+"."+Ku(o,3)+"Z":i?"T"+Ku(e,2)+":"+Ku(r,2)+":"+Ku(i,2)+"Z":r||e?"T"+Ku(e,2)+":"+Ku(r,2)+"Z":"")}function Ju(t){var n=new RegExp('["'+t+"\n\r]"),e=t.charCodeAt(0);function r(t,n){var r,i=[],o=t.length,a=0,u=0,c=o<=0,f=!1;function s(){if(c)return Hu;if(f)return f=!1,ju;var n,r,i=a;if(t.charCodeAt(i)===Xu){for(;a++<o&&t.charCodeAt(a)!==Xu||t.charCodeAt(++a)===Xu;);return(n=a)>=o?c=!0:(r=t.charCodeAt(a++))===Gu?f=!0:r===Vu&&(f=!0,t.charCodeAt(a)===Gu&&++a),t.slice(i+1,n-1).replace(/""/g,'"')}for(;a<o;){if((r=t.charCodeAt(n=a++))===Gu)f=!0;else if(r===Vu)f=!0,t.charCodeAt(a)===Gu&&++a;else if(r!==e)continue;return t.slice(i,n)}return c=!0,t.slice(i,o)}for(t.charCodeAt(o-1)===Gu&&--o,t.charCodeAt(o-1)===Vu&&--o;(r=s())!==Hu;){for(var l=[];r!==ju&&r!==Hu;)l.push(r),r=s();n&&null==(l=n(l,u++))||i.push(l)}return i}function i(n,e){return n.map((function(n){return e.map((function(t){return a(n[t])})).join(t)}))}function o(n){return n.map(a).join(t)}function a(t){return null==t?"":t instanceof Date?Qu(t):n.test(t+="")?'"'+t.replace(/"/g,'""')+'"':t}return{parse:function(t,n){var e,i,o=r(t,(function(t,r){if(e)return e(t,r-1);i=t,e=n?function(t,n){var e=Wu(t);return function(r,i){return n(e(r),i,t)}}(t,n):Wu(t)}));return o.columns=i||[],o},parseRows:r,format:function(n,e){return null==e&&(e=Zu(n)),[e.map(a).join(t)].concat(i(n,e)).join("\n")},formatBody:function(t,n){return null==n&&(n=Zu(t)),i(t,n).join("\n")},formatRows:function(t){return t.map(o).join("\n")},formatRow:o,formatValue:a}}var tc=Ju(","),nc=tc.parse,ec=tc.parseRows,rc=tc.format,ic=tc.formatBody,oc=tc.formatRows,ac=tc.formatRow,uc=tc.formatValue,cc=Ju("\t"),fc=cc.parse,sc=cc.parseRows,lc=cc.format,hc=cc.formatBody,dc=cc.formatRows,pc=cc.formatRow,gc=cc.formatValue;const yc=new Date("2019-01-01T00:00").getHours()||new Date("2019-07-01T00:00").getHours();function vc(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.blob()}function _c(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.arrayBuffer()}function bc(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);return t.text()}function mc(t,n){return fetch(t,n).then(bc)}function xc(t){return function(n,e,r){return 2===arguments.length&&"function"==typeof e&&(r=e,e=void 0),mc(n,e).then((function(n){return t(n,r)}))}}var wc=xc(nc),Mc=xc(fc);function Tc(t){if(!t.ok)throw new Error(t.status+" "+t.statusText);if(204!==t.status&&205!==t.status)return t.json()}function Ac(t){return(n,e)=>mc(n,e).then((n=>(new DOMParser).parseFromString(n,t)))}var Sc=Ac("application/xml"),Ec=Ac("text/html"),Nc=Ac("image/svg+xml");function kc(t,n,e,r){if(isNaN(n)||isNaN(e))return t;var i,o,a,u,c,f,s,l,h,d=t._root,p={data:r},g=t._x0,y=t._y0,v=t._x1,_=t._y1;if(!d)return t._root=p,t;for(;d.length;)if((f=n>=(o=(g+v)/2))?g=o:v=o,(s=e>=(a=(y+_)/2))?y=a:_=a,i=d,!(d=d[l=s<<1|f]))return i[l]=p,t;if(u=+t._x.call(null,d.data),c=+t._y.call(null,d.data),n===u&&e===c)return p.next=d,i?i[l]=p:t._root=p,t;do{i=i?i[l]=new Array(4):t._root=new Array(4),(f=n>=(o=(g+v)/2))?g=o:v=o,(s=e>=(a=(y+_)/2))?y=a:_=a}while((l=s<<1|f)==(h=(c>=a)<<1|u>=o));return i[h]=d,i[l]=p,t}function Cc(t,n,e,r,i){this.node=t,this.x0=n,this.y0=e,this.x1=r,this.y1=i}function Pc(t){return t[0]}function zc(t){return t[1]}function $c(t,n,e){var r=new Dc(null==n?Pc:n,null==e?zc:e,NaN,NaN,NaN,NaN);return null==t?r:r.addAll(t)}function Dc(t,n,e,r,i,o){this._x=t,this._y=n,this._x0=e,this._y0=r,this._x1=i,this._y1=o,this._root=void 0}function Rc(t){for(var n={data:t.data},e=n;t=t.next;)e=e.next={data:t.data};return n}var Fc=$c.prototype=Dc.prototype;function qc(t){return function(){return t}}function Uc(t){return 1e-6*(t()-.5)}function Ic(t){return t.x+t.vx}function Oc(t){return t.y+t.vy}function Bc(t){return t.index}function Yc(t,n){var e=t.get(n);if(!e)throw new Error("node not found: "+n);return e}Fc.copy=function(){var t,n,e=new Dc(this._x,this._y,this._x0,this._y0,this._x1,this._y1),r=this._root;if(!r)return e;if(!r.length)return e._root=Rc(r),e;for(t=[{source:r,target:e._root=new Array(4)}];r=t.pop();)for(var i=0;i<4;++i)(n=r.source[i])&&(n.length?t.push({source:n,target:r.target[i]=new Array(4)}):r.target[i]=Rc(n));return e},Fc.add=function(t){const n=+this._x.call(null,t),e=+this._y.call(null,t);return kc(this.cover(n,e),n,e,t)},Fc.addAll=function(t){var n,e,r,i,o=t.length,a=new Array(o),u=new Array(o),c=1/0,f=1/0,s=-1/0,l=-1/0;for(e=0;e<o;++e)isNaN(r=+this._x.call(null,n=t[e]))||isNaN(i=+this._y.call(null,n))||(a[e]=r,u[e]=i,r<c&&(c=r),r>s&&(s=r),i<f&&(f=i),i>l&&(l=i));if(c>s||f>l)return this;for(this.cover(c,f).cover(s,l),e=0;e<o;++e)kc(this,a[e],u[e],t[e]);return this},Fc.cover=function(t,n){if(isNaN(t=+t)||isNaN(n=+n))return this;var e=this._x0,r=this._y0,i=this._x1,o=this._y1;if(isNaN(e))i=(e=Math.floor(t))+1,o=(r=Math.floor(n))+1;else{for(var a,u,c=i-e||1,f=this._root;e>t||t>=i||r>n||n>=o;)switch(u=(n<r)<<1|t<e,(a=new Array(4))[u]=f,f=a,c*=2,u){case 0:i=e+c,o=r+c;break;case 1:e=i-c,o=r+c;break;case 2:i=e+c,r=o-c;break;case 3:e=i-c,r=o-c}this._root&&this._root.length&&(this._root=f)}return this._x0=e,this._y0=r,this._x1=i,this._y1=o,this},Fc.data=function(){var t=[];return this.visit((function(n){if(!n.length)do{t.push(n.data)}while(n=n.next)})),t},Fc.extent=function(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},Fc.find=function(t,n,e){var r,i,o,a,u,c,f,s=this._x0,l=this._y0,h=this._x1,d=this._y1,p=[],g=this._root;for(g&&p.push(new Cc(g,s,l,h,d)),null==e?e=1/0:(s=t-e,l=n-e,h=t+e,d=n+e,e*=e);c=p.pop();)if(!(!(g=c.node)||(i=c.x0)>h||(o=c.y0)>d||(a=c.x1)<s||(u=c.y1)<l))if(g.length){var y=(i+a)/2,v=(o+u)/2;p.push(new Cc(g[3],y,v,a,u),new Cc(g[2],i,v,y,u),new Cc(g[1],y,o,a,v),new Cc(g[0],i,o,y,v)),(f=(n>=v)<<1|t>=y)&&(c=p[p.length-1],p[p.length-1]=p[p.length-1-f],p[p.length-1-f]=c)}else{var _=t-+this._x.call(null,g.data),b=n-+this._y.call(null,g.data),m=_*_+b*b;if(m<e){var x=Math.sqrt(e=m);s=t-x,l=n-x,h=t+x,d=n+x,r=g.data}}return r},Fc.remove=function(t){if(isNaN(o=+this._x.call(null,t))||isNaN(a=+this._y.call(null,t)))return this;var n,e,r,i,o,a,u,c,f,s,l,h,d=this._root,p=this._x0,g=this._y0,y=this._x1,v=this._y1;if(!d)return this;if(d.length)for(;;){if((f=o>=(u=(p+y)/2))?p=u:y=u,(s=a>=(c=(g+v)/2))?g=c:v=c,n=d,!(d=d[l=s<<1|f]))return this;if(!d.length)break;(n[l+1&3]||n[l+2&3]||n[l+3&3])&&(e=n,h=l)}for(;d.data!==t;)if(r=d,!(d=d.next))return this;return(i=d.next)&&delete d.next,r?(i?r.next=i:delete r.next,this):n?(i?n[l]=i:delete n[l],(d=n[0]||n[1]||n[2]||n[3])&&d===(n[3]||n[2]||n[1]||n[0])&&!d.length&&(e?e[h]=d:this._root=d),this):(this._root=i,this)},Fc.removeAll=function(t){for(var n=0,e=t.length;n<e;++n)this.remove(t[n]);return this},Fc.root=function(){return this._root},Fc.size=function(){var t=0;return this.visit((function(n){if(!n.length)do{++t}while(n=n.next)})),t},Fc.visit=function(t){var n,e,r,i,o,a,u=[],c=this._root;for(c&&u.push(new Cc(c,this._x0,this._y0,this._x1,this._y1));n=u.pop();)if(!t(c=n.node,r=n.x0,i=n.y0,o=n.x1,a=n.y1)&&c.length){var f=(r+o)/2,s=(i+a)/2;(e=c[3])&&u.push(new Cc(e,f,s,o,a)),(e=c[2])&&u.push(new Cc(e,r,s,f,a)),(e=c[1])&&u.push(new Cc(e,f,i,o,s)),(e=c[0])&&u.push(new Cc(e,r,i,f,s))}return this},Fc.visitAfter=function(t){var n,e=[],r=[];for(this._root&&e.push(new Cc(this._root,this._x0,this._y0,this._x1,this._y1));n=e.pop();){var i=n.node;if(i.length){var o,a=n.x0,u=n.y0,c=n.x1,f=n.y1,s=(a+c)/2,l=(u+f)/2;(o=i[0])&&e.push(new Cc(o,a,u,s,l)),(o=i[1])&&e.push(new Cc(o,s,u,c,l)),(o=i[2])&&e.push(new Cc(o,a,l,s,f)),(o=i[3])&&e.push(new Cc(o,s,l,c,f))}r.push(n)}for(;n=r.pop();)t(n.node,n.x0,n.y0,n.x1,n.y1);return this},Fc.x=function(t){return arguments.length?(this._x=t,this):this._x},Fc.y=function(t){return arguments.length?(this._y=t,this):this._y};const Lc=1664525,jc=1013904223,Hc=4294967296;function Xc(t){return t.x}function Gc(t){return t.y}var Vc=Math.PI*(3-Math.sqrt(5));function Wc(t,n){if((e=(t=n?t.toExponential(n-1):t.toExponential()).indexOf("e"))<0)return null;var e,r=t.slice(0,e);return[r.length>1?r[0]+r.slice(2):r,+t.slice(e+1)]}function Zc(t){return(t=Wc(Math.abs(t)))?t[1]:NaN}var Kc,Qc=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Jc(t){if(!(n=Qc.exec(t)))throw new Error("invalid format: "+t);var n;return new tf({fill:n[1],align:n[2],sign:n[3],symbol:n[4],zero:n[5],width:n[6],comma:n[7],precision:n[8]&&n[8].slice(1),trim:n[9],type:n[10]})}function tf(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function nf(t,n){var e=Wc(t,n);if(!e)return t+"";var r=e[0],i=e[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}Jc.prototype=tf.prototype,tf.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var ef={"%":(t,n)=>(100*t).toFixed(n),b:t=>Math.round(t).toString(2),c:t=>t+"",d:function(t){return Math.abs(t=Math.round(t))>=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)},e:(t,n)=>t.toExponential(n),f:(t,n)=>t.toFixed(n),g:(t,n)=>t.toPrecision(n),o:t=>Math.round(t).toString(8),p:(t,n)=>nf(100*t,n),r:nf,s:function(t,n){var e=Wc(t,n);if(!e)return t+"";var r=e[0],i=e[1],o=i-(Kc=3*Math.max(-8,Math.min(8,Math.floor(i/3))))+1,a=r.length;return o===a?r:o>a?r+new Array(o-a+1).join("0"):o>0?r.slice(0,o)+"."+r.slice(o):"0."+new Array(1-o).join("0")+Wc(t,Math.max(0,n+o-1))[0]},X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function rf(t){return t}var of,af=Array.prototype.map,uf=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function cf(t){var n,e,r=void 0===t.grouping||void 0===t.thousands?rf:(n=af.call(t.grouping,Number),e=t.thousands+"",function(t,r){for(var i=t.length,o=[],a=0,u=n[0],c=0;i>0&&u>0&&(c+u+1>r&&(u=Math.max(1,r-c)),o.push(t.substring(i-=u,i+u)),!((c+=u+1)>r));)u=n[a=(a+1)%n.length];return o.reverse().join(e)}),i=void 0===t.currency?"":t.currency[0]+"",o=void 0===t.currency?"":t.currency[1]+"",a=void 0===t.decimal?".":t.decimal+"",u=void 0===t.numerals?rf:function(t){return function(n){return n.replace(/[0-9]/g,(function(n){return t[+n]}))}}(af.call(t.numerals,String)),c=void 0===t.percent?"%":t.percent+"",f=void 0===t.minus?"−":t.minus+"",s=void 0===t.nan?"NaN":t.nan+"";function l(t){var n=(t=Jc(t)).fill,e=t.align,l=t.sign,h=t.symbol,d=t.zero,p=t.width,g=t.comma,y=t.precision,v=t.trim,_=t.type;"n"===_?(g=!0,_="g"):ef[_]||(void 0===y&&(y=12),v=!0,_="g"),(d||"0"===n&&"="===e)&&(d=!0,n="0",e="=");var b="$"===h?i:"#"===h&&/[boxX]/.test(_)?"0"+_.toLowerCase():"",m="$"===h?o:/[%p]/.test(_)?c:"",x=ef[_],w=/[defgprs%]/.test(_);function M(t){var i,o,c,h=b,M=m;if("c"===_)M=x(t)+M,t="";else{var T=(t=+t)<0||1/t<0;if(t=isNaN(t)?s:x(Math.abs(t),y),v&&(t=function(t){t:for(var n,e=t.length,r=1,i=-1;r<e;++r)switch(t[r]){case".":i=n=r;break;case"0":0===i&&(i=r),n=r;break;default:if(!+t[r])break t;i>0&&(i=0)}return i>0?t.slice(0,i)+t.slice(n+1):t}(t)),T&&0==+t&&"+"!==l&&(T=!1),h=(T?"("===l?l:f:"-"===l||"("===l?"":l)+h,M=("s"===_?uf[8+Kc/3]:"")+M+(T&&"("===l?")":""),w)for(i=-1,o=t.length;++i<o;)if(48>(c=t.charCodeAt(i))||c>57){M=(46===c?a+t.slice(i+1):t.slice(i))+M,t=t.slice(0,i);break}}g&&!d&&(t=r(t,1/0));var A=h.length+t.length+M.length,S=A<p?new Array(p-A+1).join(n):"";switch(g&&d&&(t=r(S+t,S.length?p-M.length:1/0),S=""),e){case"<":t=h+t+M+S;break;case"=":t=h+S+t+M;break;case"^":t=S.slice(0,A=S.length>>1)+h+t+M+S.slice(A);break;default:t=S+h+t+M}return u(t)}return y=void 0===y?6:/[gprs]/.test(_)?Math.max(1,Math.min(21,y)):Math.max(0,Math.min(20,y)),M.toString=function(){return t+""},M}return{format:l,formatPrefix:function(t,n){var e=l(((t=Jc(t)).type="f",t)),r=3*Math.max(-8,Math.min(8,Math.floor(Zc(n)/3))),i=Math.pow(10,-r),o=uf[8+r/3];return function(t){return e(i*t)+o}}}}function ff(n){return of=cf(n),t.format=of.format,t.formatPrefix=of.formatPrefix,of}function sf(t){return Math.max(0,-Zc(Math.abs(t)))}function lf(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(Zc(n)/3)))-Zc(Math.abs(t)))}function hf(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,Zc(n)-Zc(t))+1}t.format=void 0,t.formatPrefix=void 0,ff({thousands:",",grouping:[3],currency:["$",""]});var df=1e-6,pf=1e-12,gf=Math.PI,yf=gf/2,vf=gf/4,_f=2*gf,bf=180/gf,mf=gf/180,xf=Math.abs,wf=Math.atan,Mf=Math.atan2,Tf=Math.cos,Af=Math.ceil,Sf=Math.exp,Ef=Math.hypot,Nf=Math.log,kf=Math.pow,Cf=Math.sin,Pf=Math.sign||function(t){return t>0?1:t<0?-1:0},zf=Math.sqrt,$f=Math.tan;function Df(t){return t>1?0:t<-1?gf:Math.acos(t)}function Rf(t){return t>1?yf:t<-1?-yf:Math.asin(t)}function Ff(t){return(t=Cf(t/2))*t}function qf(){}function Uf(t,n){t&&Of.hasOwnProperty(t.type)&&Of[t.type](t,n)}var If={Feature:function(t,n){Uf(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)Uf(e[r].geometry,n)}},Of={Sphere:function(t,n){n.sphere()},Point:function(t,n){t=t.coordinates,n.point(t[0],t[1],t[2])},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)t=e[r],n.point(t[0],t[1],t[2])},LineString:function(t,n){Bf(t.coordinates,n,0)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)Bf(e[r],n,0)},Polygon:function(t,n){Yf(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)Yf(e[r],n)},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)Uf(e[r],n)}};function Bf(t,n,e){var r,i=-1,o=t.length-e;for(n.lineStart();++i<o;)r=t[i],n.point(r[0],r[1],r[2]);n.lineEnd()}function Yf(t,n){var e=-1,r=t.length;for(n.polygonStart();++e<r;)Bf(t[e],n,1);n.polygonEnd()}function Lf(t,n){t&&If.hasOwnProperty(t.type)?If[t.type](t,n):Uf(t,n)}var jf,Hf,Xf,Gf,Vf,Wf,Zf,Kf,Qf,Jf,ts,ns,es,rs,is,os,as=new T,us=new T,cs={point:qf,lineStart:qf,lineEnd:qf,polygonStart:function(){as=new T,cs.lineStart=fs,cs.lineEnd=ss},polygonEnd:function(){var t=+as;us.add(t<0?_f+t:t),this.lineStart=this.lineEnd=this.point=qf},sphere:function(){us.add(_f)}};function fs(){cs.point=ls}function ss(){hs(jf,Hf)}function ls(t,n){cs.point=hs,jf=t,Hf=n,Xf=t*=mf,Gf=Tf(n=(n*=mf)/2+vf),Vf=Cf(n)}function hs(t,n){var e=(t*=mf)-Xf,r=e>=0?1:-1,i=r*e,o=Tf(n=(n*=mf)/2+vf),a=Cf(n),u=Vf*a,c=Gf*o+u*Tf(i),f=u*r*Cf(i);as.add(Mf(f,c)),Xf=t,Gf=o,Vf=a}function ds(t){return[Mf(t[1],t[0]),Rf(t[2])]}function ps(t){var n=t[0],e=t[1],r=Tf(e);return[r*Tf(n),r*Cf(n),Cf(e)]}function gs(t,n){return t[0]*n[0]+t[1]*n[1]+t[2]*n[2]}function ys(t,n){return[t[1]*n[2]-t[2]*n[1],t[2]*n[0]-t[0]*n[2],t[0]*n[1]-t[1]*n[0]]}function vs(t,n){t[0]+=n[0],t[1]+=n[1],t[2]+=n[2]}function _s(t,n){return[t[0]*n,t[1]*n,t[2]*n]}function bs(t){var n=zf(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=n,t[1]/=n,t[2]/=n}var ms,xs,ws,Ms,Ts,As,Ss,Es,Ns,ks,Cs,Ps,zs,$s,Ds,Rs,Fs={point:qs,lineStart:Is,lineEnd:Os,polygonStart:function(){Fs.point=Bs,Fs.lineStart=Ys,Fs.lineEnd=Ls,rs=new T,cs.polygonStart()},polygonEnd:function(){cs.polygonEnd(),Fs.point=qs,Fs.lineStart=Is,Fs.lineEnd=Os,as<0?(Wf=-(Kf=180),Zf=-(Qf=90)):rs>df?Qf=90:rs<-df&&(Zf=-90),os[0]=Wf,os[1]=Kf},sphere:function(){Wf=-(Kf=180),Zf=-(Qf=90)}};function qs(t,n){is.push(os=[Wf=t,Kf=t]),n<Zf&&(Zf=n),n>Qf&&(Qf=n)}function Us(t,n){var e=ps([t*mf,n*mf]);if(es){var r=ys(es,e),i=ys([r[1],-r[0],0],r);bs(i),i=ds(i);var o,a=t-Jf,u=a>0?1:-1,c=i[0]*bf*u,f=xf(a)>180;f^(u*Jf<c&&c<u*t)?(o=i[1]*bf)>Qf&&(Qf=o):f^(u*Jf<(c=(c+360)%360-180)&&c<u*t)?(o=-i[1]*bf)<Zf&&(Zf=o):(n<Zf&&(Zf=n),n>Qf&&(Qf=n)),f?t<Jf?js(Wf,t)>js(Wf,Kf)&&(Kf=t):js(t,Kf)>js(Wf,Kf)&&(Wf=t):Kf>=Wf?(t<Wf&&(Wf=t),t>Kf&&(Kf=t)):t>Jf?js(Wf,t)>js(Wf,Kf)&&(Kf=t):js(t,Kf)>js(Wf,Kf)&&(Wf=t)}else is.push(os=[Wf=t,Kf=t]);n<Zf&&(Zf=n),n>Qf&&(Qf=n),es=e,Jf=t}function Is(){Fs.point=Us}function Os(){os[0]=Wf,os[1]=Kf,Fs.point=qs,es=null}function Bs(t,n){if(es){var e=t-Jf;rs.add(xf(e)>180?e+(e>0?360:-360):e)}else ts=t,ns=n;cs.point(t,n),Us(t,n)}function Ys(){cs.lineStart()}function Ls(){Bs(ts,ns),cs.lineEnd(),xf(rs)>df&&(Wf=-(Kf=180)),os[0]=Wf,os[1]=Kf,es=null}function js(t,n){return(n-=t)<0?n+360:n}function Hs(t,n){return t[0]-n[0]}function Xs(t,n){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:n<t[0]||t[1]<n}var Gs={sphere:qf,point:Vs,lineStart:Zs,lineEnd:Js,polygonStart:function(){Gs.lineStart=tl,Gs.lineEnd=nl},polygonEnd:function(){Gs.lineStart=Zs,Gs.lineEnd=Js}};function Vs(t,n){t*=mf;var e=Tf(n*=mf);Ws(e*Tf(t),e*Cf(t),Cf(n))}function Ws(t,n,e){++ms,ws+=(t-ws)/ms,Ms+=(n-Ms)/ms,Ts+=(e-Ts)/ms}function Zs(){Gs.point=Ks}function Ks(t,n){t*=mf;var e=Tf(n*=mf);$s=e*Tf(t),Ds=e*Cf(t),Rs=Cf(n),Gs.point=Qs,Ws($s,Ds,Rs)}function Qs(t,n){t*=mf;var e=Tf(n*=mf),r=e*Tf(t),i=e*Cf(t),o=Cf(n),a=Mf(zf((a=Ds*o-Rs*i)*a+(a=Rs*r-$s*o)*a+(a=$s*i-Ds*r)*a),$s*r+Ds*i+Rs*o);xs+=a,As+=a*($s+($s=r)),Ss+=a*(Ds+(Ds=i)),Es+=a*(Rs+(Rs=o)),Ws($s,Ds,Rs)}function Js(){Gs.point=Vs}function tl(){Gs.point=el}function nl(){rl(Ps,zs),Gs.point=Vs}function el(t,n){Ps=t,zs=n,t*=mf,n*=mf,Gs.point=rl;var e=Tf(n);$s=e*Tf(t),Ds=e*Cf(t),Rs=Cf(n),Ws($s,Ds,Rs)}function rl(t,n){t*=mf;var e=Tf(n*=mf),r=e*Tf(t),i=e*Cf(t),o=Cf(n),a=Ds*o-Rs*i,u=Rs*r-$s*o,c=$s*i-Ds*r,f=Ef(a,u,c),s=Rf(f),l=f&&-s/f;Ns.add(l*a),ks.add(l*u),Cs.add(l*c),xs+=s,As+=s*($s+($s=r)),Ss+=s*(Ds+(Ds=i)),Es+=s*(Rs+(Rs=o)),Ws($s,Ds,Rs)}function il(t){return function(){return t}}function ol(t,n){function e(e,r){return e=t(e,r),n(e[0],e[1])}return t.invert&&n.invert&&(e.invert=function(e,r){return(e=n.invert(e,r))&&t.invert(e[0],e[1])}),e}function al(t,n){return xf(t)>gf&&(t-=Math.round(t/_f)*_f),[t,n]}function ul(t,n,e){return(t%=_f)?n||e?ol(fl(t),sl(n,e)):fl(t):n||e?sl(n,e):al}function cl(t){return function(n,e){return xf(n+=t)>gf&&(n-=Math.round(n/_f)*_f),[n,e]}}function fl(t){var n=cl(t);return n.invert=cl(-t),n}function sl(t,n){var e=Tf(t),r=Cf(t),i=Tf(n),o=Cf(n);function a(t,n){var a=Tf(n),u=Tf(t)*a,c=Cf(t)*a,f=Cf(n),s=f*e+u*r;return[Mf(c*i-s*o,u*e-f*r),Rf(s*i+c*o)]}return a.invert=function(t,n){var a=Tf(n),u=Tf(t)*a,c=Cf(t)*a,f=Cf(n),s=f*i-c*o;return[Mf(c*i+f*o,u*e+s*r),Rf(s*e-u*r)]},a}function ll(t){function n(n){return(n=t(n[0]*mf,n[1]*mf))[0]*=bf,n[1]*=bf,n}return t=ul(t[0]*mf,t[1]*mf,t.length>2?t[2]*mf:0),n.invert=function(n){return(n=t.invert(n[0]*mf,n[1]*mf))[0]*=bf,n[1]*=bf,n},n}function hl(t,n,e,r,i,o){if(e){var a=Tf(n),u=Cf(n),c=r*e;null==i?(i=n+r*_f,o=n-c/2):(i=dl(a,i),o=dl(a,o),(r>0?i<o:i>o)&&(i+=r*_f));for(var f,s=i;r>0?s>o:s<o;s-=c)f=ds([a,-u*Tf(s),-u*Cf(s)]),t.point(f[0],f[1])}}function dl(t,n){(n=ps(n))[0]-=t,bs(n);var e=Df(-n[1]);return((-n[2]<0?-e:e)+_f-df)%_f}function pl(){var t,n=[];return{point:function(n,e,r){t.push([n,e,r])},lineStart:function(){n.push(t=[])},lineEnd:qf,rejoin:function(){n.length>1&&n.push(n.pop().concat(n.shift()))},result:function(){var e=n;return n=[],t=null,e}}}function gl(t,n){return xf(t[0]-n[0])<df&&xf(t[1]-n[1])<df}function yl(t,n,e,r){this.x=t,this.z=n,this.o=e,this.e=r,this.v=!1,this.n=this.p=null}function vl(t,n,e,r,i){var o,a,u=[],c=[];if(t.forEach((function(t){if(!((n=t.length-1)<=0)){var n,e,r=t[0],a=t[n];if(gl(r,a)){if(!r[2]&&!a[2]){for(i.lineStart(),o=0;o<n;++o)i.point((r=t[o])[0],r[1]);return void i.lineEnd()}a[0]+=2*df}u.push(e=new yl(r,t,null,!0)),c.push(e.o=new yl(r,null,e,!1)),u.push(e=new yl(a,t,null,!1)),c.push(e.o=new yl(a,null,e,!0))}})),u.length){for(c.sort(n),_l(u),_l(c),o=0,a=c.length;o<a;++o)c[o].e=e=!e;for(var f,s,l=u[0];;){for(var h=l,d=!0;h.v;)if((h=h.n)===l)return;f=h.z,i.lineStart();do{if(h.v=h.o.v=!0,h.e){if(d)for(o=0,a=f.length;o<a;++o)i.point((s=f[o])[0],s[1]);else r(h.x,h.n.x,1,i);h=h.n}else{if(d)for(f=h.p.z,o=f.length-1;o>=0;--o)i.point((s=f[o])[0],s[1]);else r(h.x,h.p.x,-1,i);h=h.p}f=(h=h.o).z,d=!d}while(!h.v);i.lineEnd()}}}function _l(t){if(n=t.length){for(var n,e,r=0,i=t[0];++r<n;)i.n=e=t[r],e.p=i,i=e;i.n=e=t[0],e.p=i}}function bl(t){return xf(t[0])<=gf?t[0]:Pf(t[0])*((xf(t[0])+gf)%_f-gf)}function ml(t,n){var e=bl(n),r=n[1],i=Cf(r),o=[Cf(e),-Tf(e),0],a=0,u=0,c=new T;1===i?r=yf+df:-1===i&&(r=-yf-df);for(var f=0,s=t.length;f<s;++f)if(h=(l=t[f]).length)for(var l,h,d=l[h-1],p=bl(d),g=d[1]/2+vf,y=Cf(g),v=Tf(g),_=0;_<h;++_,p=m,y=w,v=M,d=b){var b=l[_],m=bl(b),x=b[1]/2+vf,w=Cf(x),M=Tf(x),A=m-p,S=A>=0?1:-1,E=S*A,N=E>gf,k=y*w;if(c.add(Mf(k*S*Cf(E),v*M+k*Tf(E))),a+=N?A+S*_f:A,N^p>=e^m>=e){var C=ys(ps(d),ps(b));bs(C);var P=ys(o,C);bs(P);var z=(N^A>=0?-1:1)*Rf(P[2]);(r>z||r===z&&(C[0]||C[1]))&&(u+=N^A>=0?1:-1)}}return(a<-df||a<df&&c<-pf)^1&u}function xl(t,n,e,r){return function(i){var o,a,u,c=n(i),f=pl(),s=n(f),l=!1,h={point:d,lineStart:g,lineEnd:y,polygonStart:function(){h.point=v,h.lineStart=_,h.lineEnd=b,a=[],o=[]},polygonEnd:function(){h.point=d,h.lineStart=g,h.lineEnd=y,a=ft(a);var t=ml(o,r);a.length?(l||(i.polygonStart(),l=!0),vl(a,Ml,t,e,i)):t&&(l||(i.polygonStart(),l=!0),i.lineStart(),e(null,null,1,i),i.lineEnd()),l&&(i.polygonEnd(),l=!1),a=o=null},sphere:function(){i.polygonStart(),i.lineStart(),e(null,null,1,i),i.lineEnd(),i.polygonEnd()}};function d(n,e){t(n,e)&&i.point(n,e)}function p(t,n){c.point(t,n)}function g(){h.point=p,c.lineStart()}function y(){h.point=d,c.lineEnd()}function v(t,n){u.push([t,n]),s.point(t,n)}function _(){s.lineStart(),u=[]}function b(){v(u[0][0],u[0][1]),s.lineEnd();var t,n,e,r,c=s.clean(),h=f.result(),d=h.length;if(u.pop(),o.push(u),u=null,d)if(1&c){if((n=(e=h[0]).length-1)>0){for(l||(i.polygonStart(),l=!0),i.lineStart(),t=0;t<n;++t)i.point((r=e[t])[0],r[1]);i.lineEnd()}}else d>1&&2&c&&h.push(h.pop().concat(h.shift())),a.push(h.filter(wl))}return h}}function wl(t){return t.length>1}function Ml(t,n){return((t=t.x)[0]<0?t[1]-yf-df:yf-t[1])-((n=n.x)[0]<0?n[1]-yf-df:yf-n[1])}al.invert=al;var Tl=xl((function(){return!0}),(function(t){var n,e=NaN,r=NaN,i=NaN;return{lineStart:function(){t.lineStart(),n=1},point:function(o,a){var u=o>0?gf:-gf,c=xf(o-e);xf(c-gf)<df?(t.point(e,r=(r+a)/2>0?yf:-yf),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),t.point(o,r),n=0):i!==u&&c>=gf&&(xf(e-i)<df&&(e-=i*df),xf(o-u)<df&&(o-=u*df),r=function(t,n,e,r){var i,o,a=Cf(t-e);return xf(a)>df?wf((Cf(n)*(o=Tf(r))*Cf(e)-Cf(r)*(i=Tf(n))*Cf(t))/(i*o*a)):(n+r)/2}(e,r,o,a),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),n=0),t.point(e=o,r=a),i=u},lineEnd:function(){t.lineEnd(),e=r=NaN},clean:function(){return 2-n}}}),(function(t,n,e,r){var i;if(null==t)i=e*yf,r.point(-gf,i),r.point(0,i),r.point(gf,i),r.point(gf,0),r.point(gf,-i),r.point(0,-i),r.point(-gf,-i),r.point(-gf,0),r.point(-gf,i);else if(xf(t[0]-n[0])>df){var o=t[0]<n[0]?gf:-gf;i=e*o/2,r.point(-o,i),r.point(0,i),r.point(o,i)}else r.point(n[0],n[1])}),[-gf,-yf]);function Al(t){var n=Tf(t),e=2*mf,r=n>0,i=xf(n)>df;function o(t,e){return Tf(t)*Tf(e)>n}function a(t,e,r){var i=[1,0,0],o=ys(ps(t),ps(e)),a=gs(o,o),u=o[0],c=a-u*u;if(!c)return!r&&t;var f=n*a/c,s=-n*u/c,l=ys(i,o),h=_s(i,f);vs(h,_s(o,s));var d=l,p=gs(h,d),g=gs(d,d),y=p*p-g*(gs(h,h)-1);if(!(y<0)){var v=zf(y),_=_s(d,(-p-v)/g);if(vs(_,h),_=ds(_),!r)return _;var b,m=t[0],x=e[0],w=t[1],M=e[1];x<m&&(b=m,m=x,x=b);var T=x-m,A=xf(T-gf)<df;if(!A&&M<w&&(b=w,w=M,M=b),A||T<df?A?w+M>0^_[1]<(xf(_[0]-m)<df?w:M):w<=_[1]&&_[1]<=M:T>gf^(m<=_[0]&&_[0]<=x)){var S=_s(d,(-p+v)/g);return vs(S,h),[_,ds(S)]}}}function u(n,e){var i=r?t:gf-t,o=0;return n<-i?o|=1:n>i&&(o|=2),e<-i?o|=4:e>i&&(o|=8),o}return xl(o,(function(t){var n,e,c,f,s;return{lineStart:function(){f=c=!1,s=1},point:function(l,h){var d,p=[l,h],g=o(l,h),y=r?g?0:u(l,h):g?u(l+(l<0?gf:-gf),h):0;if(!n&&(f=c=g)&&t.lineStart(),g!==c&&(!(d=a(n,p))||gl(n,d)||gl(p,d))&&(p[2]=1),g!==c)s=0,g?(t.lineStart(),d=a(p,n),t.point(d[0],d[1])):(d=a(n,p),t.point(d[0],d[1],2),t.lineEnd()),n=d;else if(i&&n&&r^g){var v;y&e||!(v=a(p,n,!0))||(s=0,r?(t.lineStart(),t.point(v[0][0],v[0][1]),t.point(v[1][0],v[1][1]),t.lineEnd()):(t.point(v[1][0],v[1][1]),t.lineEnd(),t.lineStart(),t.point(v[0][0],v[0][1],3)))}!g||n&&gl(n,p)||t.point(p[0],p[1]),n=p,c=g,e=y},lineEnd:function(){c&&t.lineEnd(),n=null},clean:function(){return s|(f&&c)<<1}}}),(function(n,r,i,o){hl(o,t,e,i,n,r)}),r?[0,-t]:[-gf,t-gf])}var Sl,El,Nl,kl,Cl=1e9,Pl=-Cl;function zl(t,n,e,r){function i(i,o){return t<=i&&i<=e&&n<=o&&o<=r}function o(i,o,u,f){var s=0,l=0;if(null==i||(s=a(i,u))!==(l=a(o,u))||c(i,o)<0^u>0)do{f.point(0===s||3===s?t:e,s>1?r:n)}while((s=(s+u+4)%4)!==l);else f.point(o[0],o[1])}function a(r,i){return xf(r[0]-t)<df?i>0?0:3:xf(r[0]-e)<df?i>0?2:1:xf(r[1]-n)<df?i>0?1:0:i>0?3:2}function u(t,n){return c(t.x,n.x)}function c(t,n){var e=a(t,1),r=a(n,1);return e!==r?e-r:0===e?n[1]-t[1]:1===e?t[0]-n[0]:2===e?t[1]-n[1]:n[0]-t[0]}return function(a){var c,f,s,l,h,d,p,g,y,v,_,b=a,m=pl(),x={point:w,lineStart:function(){x.point=M,f&&f.push(s=[]);v=!0,y=!1,p=g=NaN},lineEnd:function(){c&&(M(l,h),d&&y&&m.rejoin(),c.push(m.result()));x.point=w,y&&b.lineEnd()},polygonStart:function(){b=m,c=[],f=[],_=!0},polygonEnd:function(){var n=function(){for(var n=0,e=0,i=f.length;e<i;++e)for(var o,a,u=f[e],c=1,s=u.length,l=u[0],h=l[0],d=l[1];c<s;++c)o=h,a=d,h=(l=u[c])[0],d=l[1],a<=r?d>r&&(h-o)*(r-a)>(d-a)*(t-o)&&++n:d<=r&&(h-o)*(r-a)<(d-a)*(t-o)&&--n;return n}(),e=_&&n,i=(c=ft(c)).length;(e||i)&&(a.polygonStart(),e&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),i&&vl(c,u,n,o,a),a.polygonEnd());b=a,c=f=s=null}};function w(t,n){i(t,n)&&b.point(t,n)}function M(o,a){var u=i(o,a);if(f&&s.push([o,a]),v)l=o,h=a,d=u,v=!1,u&&(b.lineStart(),b.point(o,a));else if(u&&y)b.point(o,a);else{var c=[p=Math.max(Pl,Math.min(Cl,p)),g=Math.max(Pl,Math.min(Cl,g))],m=[o=Math.max(Pl,Math.min(Cl,o)),a=Math.max(Pl,Math.min(Cl,a))];!function(t,n,e,r,i,o){var a,u=t[0],c=t[1],f=0,s=1,l=n[0]-u,h=n[1]-c;if(a=e-u,l||!(a>0)){if(a/=l,l<0){if(a<f)return;a<s&&(s=a)}else if(l>0){if(a>s)return;a>f&&(f=a)}if(a=i-u,l||!(a<0)){if(a/=l,l<0){if(a>s)return;a>f&&(f=a)}else if(l>0){if(a<f)return;a<s&&(s=a)}if(a=r-c,h||!(a>0)){if(a/=h,h<0){if(a<f)return;a<s&&(s=a)}else if(h>0){if(a>s)return;a>f&&(f=a)}if(a=o-c,h||!(a<0)){if(a/=h,h<0){if(a>s)return;a>f&&(f=a)}else if(h>0){if(a<f)return;a<s&&(s=a)}return f>0&&(t[0]=u+f*l,t[1]=c+f*h),s<1&&(n[0]=u+s*l,n[1]=c+s*h),!0}}}}}(c,m,t,n,e,r)?u&&(b.lineStart(),b.point(o,a),_=!1):(y||(b.lineStart(),b.point(c[0],c[1])),b.point(m[0],m[1]),u||b.lineEnd(),_=!1)}p=o,g=a,y=u}return x}}var $l={sphere:qf,point:qf,lineStart:function(){$l.point=Rl,$l.lineEnd=Dl},lineEnd:qf,polygonStart:qf,polygonEnd:qf};function Dl(){$l.point=$l.lineEnd=qf}function Rl(t,n){El=t*=mf,Nl=Cf(n*=mf),kl=Tf(n),$l.point=Fl}function Fl(t,n){t*=mf;var e=Cf(n*=mf),r=Tf(n),i=xf(t-El),o=Tf(i),a=r*Cf(i),u=kl*e-Nl*r*o,c=Nl*e+kl*r*o;Sl.add(Mf(zf(a*a+u*u),c)),El=t,Nl=e,kl=r}function ql(t){return Sl=new T,Lf(t,$l),+Sl}var Ul=[null,null],Il={type:"LineString",coordinates:Ul};function Ol(t,n){return Ul[0]=t,Ul[1]=n,ql(Il)}var Bl={Feature:function(t,n){return Ll(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r<i;)if(Ll(e[r].geometry,n))return!0;return!1}},Yl={Sphere:function(){return!0},Point:function(t,n){return jl(t.coordinates,n)},MultiPoint:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(jl(e[r],n))return!0;return!1},LineString:function(t,n){return Hl(t.coordinates,n)},MultiLineString:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(Hl(e[r],n))return!0;return!1},Polygon:function(t,n){return Xl(t.coordinates,n)},MultiPolygon:function(t,n){for(var e=t.coordinates,r=-1,i=e.length;++r<i;)if(Xl(e[r],n))return!0;return!1},GeometryCollection:function(t,n){for(var e=t.geometries,r=-1,i=e.length;++r<i;)if(Ll(e[r],n))return!0;return!1}};function Ll(t,n){return!(!t||!Yl.hasOwnProperty(t.type))&&Yl[t.type](t,n)}function jl(t,n){return 0===Ol(t,n)}function Hl(t,n){for(var e,r,i,o=0,a=t.length;o<a;o++){if(0===(r=Ol(t[o],n)))return!0;if(o>0&&(i=Ol(t[o],t[o-1]))>0&&e<=i&&r<=i&&(e+r-i)*(1-Math.pow((e-r)/i,2))<pf*i)return!0;e=r}return!1}function Xl(t,n){return!!ml(t.map(Gl),Vl(n))}function Gl(t){return(t=t.map(Vl)).pop(),t}function Vl(t){return[t[0]*mf,t[1]*mf]}function Wl(t,n,e){var r=lt(t,n-df,e).concat(n);return function(t){return r.map((function(n){return[t,n]}))}}function Zl(t,n,e){var r=lt(t,n-df,e).concat(n);return function(t){return r.map((function(n){return[n,t]}))}}function Kl(){var t,n,e,r,i,o,a,u,c,f,s,l,h=10,d=h,p=90,g=360,y=2.5;function v(){return{type:"MultiLineString",coordinates:_()}}function _(){return lt(Af(r/p)*p,e,p).map(s).concat(lt(Af(u/g)*g,a,g).map(l)).concat(lt(Af(n/h)*h,t,h).filter((function(t){return xf(t%p)>df})).map(c)).concat(lt(Af(o/d)*d,i,d).filter((function(t){return xf(t%g)>df})).map(f))}return v.lines=function(){return _().map((function(t){return{type:"LineString",coordinates:t}}))},v.outline=function(){return{type:"Polygon",coordinates:[s(r).concat(l(a).slice(1),s(e).reverse().slice(1),l(u).reverse().slice(1))]}},v.extent=function(t){return arguments.length?v.extentMajor(t).extentMinor(t):v.extentMinor()},v.extentMajor=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],u=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),u>a&&(t=u,u=a,a=t),v.precision(y)):[[r,u],[e,a]]},v.extentMinor=function(e){return arguments.length?(n=+e[0][0],t=+e[1][0],o=+e[0][1],i=+e[1][1],n>t&&(e=n,n=t,t=e),o>i&&(e=o,o=i,i=e),v.precision(y)):[[n,o],[t,i]]},v.step=function(t){return arguments.length?v.stepMajor(t).stepMinor(t):v.stepMinor()},v.stepMajor=function(t){return arguments.length?(p=+t[0],g=+t[1],v):[p,g]},v.stepMinor=function(t){return arguments.length?(h=+t[0],d=+t[1],v):[h,d]},v.precision=function(h){return arguments.length?(y=+h,c=Wl(o,i,90),f=Zl(n,t,y),s=Wl(u,a,90),l=Zl(r,e,y),v):y},v.extentMajor([[-180,-90+df],[180,90-df]]).extentMinor([[-180,-80-df],[180,80+df]])}var Ql,Jl,th,nh,eh=t=>t,rh=new T,ih=new T,oh={point:qf,lineStart:qf,lineEnd:qf,polygonStart:function(){oh.lineStart=ah,oh.lineEnd=fh},polygonEnd:function(){oh.lineStart=oh.lineEnd=oh.point=qf,rh.add(xf(ih)),ih=new T},result:function(){var t=rh/2;return rh=new T,t}};function ah(){oh.point=uh}function uh(t,n){oh.point=ch,Ql=th=t,Jl=nh=n}function ch(t,n){ih.add(nh*t-th*n),th=t,nh=n}function fh(){ch(Ql,Jl)}var sh=oh,lh=1/0,hh=lh,dh=-lh,ph=dh,gh={point:function(t,n){t<lh&&(lh=t);t>dh&&(dh=t);n<hh&&(hh=n);n>ph&&(ph=n)},lineStart:qf,lineEnd:qf,polygonStart:qf,polygonEnd:qf,result:function(){var t=[[lh,hh],[dh,ph]];return dh=ph=-(hh=lh=1/0),t}};var yh,vh,_h,bh,mh=gh,xh=0,wh=0,Mh=0,Th=0,Ah=0,Sh=0,Eh=0,Nh=0,kh=0,Ch={point:Ph,lineStart:zh,lineEnd:Rh,polygonStart:function(){Ch.lineStart=Fh,Ch.lineEnd=qh},polygonEnd:function(){Ch.point=Ph,Ch.lineStart=zh,Ch.lineEnd=Rh},result:function(){var t=kh?[Eh/kh,Nh/kh]:Sh?[Th/Sh,Ah/Sh]:Mh?[xh/Mh,wh/Mh]:[NaN,NaN];return xh=wh=Mh=Th=Ah=Sh=Eh=Nh=kh=0,t}};function Ph(t,n){xh+=t,wh+=n,++Mh}function zh(){Ch.point=$h}function $h(t,n){Ch.point=Dh,Ph(_h=t,bh=n)}function Dh(t,n){var e=t-_h,r=n-bh,i=zf(e*e+r*r);Th+=i*(_h+t)/2,Ah+=i*(bh+n)/2,Sh+=i,Ph(_h=t,bh=n)}function Rh(){Ch.point=Ph}function Fh(){Ch.point=Uh}function qh(){Ih(yh,vh)}function Uh(t,n){Ch.point=Ih,Ph(yh=_h=t,vh=bh=n)}function Ih(t,n){var e=t-_h,r=n-bh,i=zf(e*e+r*r);Th+=i*(_h+t)/2,Ah+=i*(bh+n)/2,Sh+=i,Eh+=(i=bh*t-_h*n)*(_h+t),Nh+=i*(bh+n),kh+=3*i,Ph(_h=t,bh=n)}var Oh=Ch;function Bh(t){this._context=t}Bh.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._context.moveTo(t,n),this._point=1;break;case 1:this._context.lineTo(t,n);break;default:this._context.moveTo(t+this._radius,n),this._context.arc(t,n,this._radius,0,_f)}},result:qf};var Yh,Lh,jh,Hh,Xh,Gh=new T,Vh={point:qf,lineStart:function(){Vh.point=Wh},lineEnd:function(){Yh&&Zh(Lh,jh),Vh.point=qf},polygonStart:function(){Yh=!0},polygonEnd:function(){Yh=null},result:function(){var t=+Gh;return Gh=new T,t}};function Wh(t,n){Vh.point=Zh,Lh=Hh=t,jh=Xh=n}function Zh(t,n){Hh-=t,Xh-=n,Gh.add(zf(Hh*Hh+Xh*Xh)),Hh=t,Xh=n}var Kh=Vh;let Qh,Jh,td,nd;class ed{constructor(t){this._append=null==t?rd:function(t){const n=Math.floor(t);if(!(n>=0))throw new RangeError(`invalid digits: ${t}`);if(n>15)return rd;if(n!==Qh){const t=10**n;Qh=n,Jh=function(n){let e=1;this._+=n[0];for(const r=n.length;e<r;++e)this._+=Math.round(arguments[e]*t)/t+n[e]}}return Jh}(t),this._radius=4.5,this._=""}pointRadius(t){return this._radius=+t,this}polygonStart(){this._line=0}polygonEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){0===this._line&&(this._+="Z"),this._point=NaN}point(t,n){switch(this._point){case 0:this._append`M${t},${n}`,this._point=1;break;case 1:this._append`L${t},${n}`;break;default:if(this._append`M${t},${n}`,this._radius!==td||this._append!==Jh){const t=this._radius,n=this._;this._="",this._append`m0,${t}a${t},${t} 0 1,1 0,${-2*t}a${t},${t} 0 1,1 0,${2*t}z`,td=t,Jh=this._append,nd=this._,this._=n}this._+=nd}}result(){const t=this._;return this._="",t.length?t:null}}function rd(t){let n=1;this._+=t[0];for(const e=t.length;n<e;++n)this._+=arguments[n]+t[n]}function id(t){return function(n){var e=new od;for(var r in t)e[r]=t[r];return e.stream=n,e}}function od(){}function ad(t,n,e){var r=t.clipExtent&&t.clipExtent();return t.scale(150).translate([0,0]),null!=r&&t.clipExtent(null),Lf(e,t.stream(mh)),n(mh.result()),null!=r&&t.clipExtent(r),t}function ud(t,n,e){return ad(t,(function(e){var r=n[1][0]-n[0][0],i=n[1][1]-n[0][1],o=Math.min(r/(e[1][0]-e[0][0]),i/(e[1][1]-e[0][1])),a=+n[0][0]+(r-o*(e[1][0]+e[0][0]))/2,u=+n[0][1]+(i-o*(e[1][1]+e[0][1]))/2;t.scale(150*o).translate([a,u])}),e)}function cd(t,n,e){return ud(t,[[0,0],n],e)}function fd(t,n,e){return ad(t,(function(e){var r=+n,i=r/(e[1][0]-e[0][0]),o=(r-i*(e[1][0]+e[0][0]))/2,a=-i*e[0][1];t.scale(150*i).translate([o,a])}),e)}function sd(t,n,e){return ad(t,(function(e){var r=+n,i=r/(e[1][1]-e[0][1]),o=-i*e[0][0],a=(r-i*(e[1][1]+e[0][1]))/2;t.scale(150*i).translate([o,a])}),e)}od.prototype={constructor:od,point:function(t,n){this.stream.point(t,n)},sphere:function(){this.stream.sphere()},lineStart:function(){this.stream.lineStart()},lineEnd:function(){this.stream.lineEnd()},polygonStart:function(){this.stream.polygonStart()},polygonEnd:function(){this.stream.polygonEnd()}};var ld=16,hd=Tf(30*mf);function dd(t,n){return+n?function(t,n){function e(r,i,o,a,u,c,f,s,l,h,d,p,g,y){var v=f-r,_=s-i,b=v*v+_*_;if(b>4*n&&g--){var m=a+h,x=u+d,w=c+p,M=zf(m*m+x*x+w*w),T=Rf(w/=M),A=xf(xf(w)-1)<df||xf(o-l)<df?(o+l)/2:Mf(x,m),S=t(A,T),E=S[0],N=S[1],k=E-r,C=N-i,P=_*k-v*C;(P*P/b>n||xf((v*k+_*C)/b-.5)>.3||a*h+u*d+c*p<hd)&&(e(r,i,o,a,u,c,E,N,A,m/=M,x/=M,w,g,y),y.point(E,N),e(E,N,A,m,x,w,f,s,l,h,d,p,g,y))}}return function(n){var r,i,o,a,u,c,f,s,l,h,d,p,g={point:y,lineStart:v,lineEnd:b,polygonStart:function(){n.polygonStart(),g.lineStart=m},polygonEnd:function(){n.polygonEnd(),g.lineStart=v}};function y(e,r){e=t(e,r),n.point(e[0],e[1])}function v(){s=NaN,g.point=_,n.lineStart()}function _(r,i){var o=ps([r,i]),a=t(r,i);e(s,l,f,h,d,p,s=a[0],l=a[1],f=r,h=o[0],d=o[1],p=o[2],ld,n),n.point(s,l)}function b(){g.point=y,n.lineEnd()}function m(){v(),g.point=x,g.lineEnd=w}function x(t,n){_(r=t,n),i=s,o=l,a=h,u=d,c=p,g.point=_}function w(){e(s,l,f,h,d,p,i,o,r,a,u,c,ld,n),g.lineEnd=b,b()}return g}}(t,n):function(t){return id({point:function(n,e){n=t(n,e),this.stream.point(n[0],n[1])}})}(t)}var pd=id({point:function(t,n){this.stream.point(t*mf,n*mf)}});function gd(t,n,e,r,i,o){if(!o)return function(t,n,e,r,i){function o(o,a){return[n+t*(o*=r),e-t*(a*=i)]}return o.invert=function(o,a){return[(o-n)/t*r,(e-a)/t*i]},o}(t,n,e,r,i);var a=Tf(o),u=Cf(o),c=a*t,f=u*t,s=a/t,l=u/t,h=(u*e-a*n)/t,d=(u*n+a*e)/t;function p(t,o){return[c*(t*=r)-f*(o*=i)+n,e-f*t-c*o]}return p.invert=function(t,n){return[r*(s*t-l*n+h),i*(d-l*t-s*n)]},p}function yd(t){return vd((function(){return t}))()}function vd(t){var n,e,r,i,o,a,u,c,f,s,l=150,h=480,d=250,p=0,g=0,y=0,v=0,_=0,b=0,m=1,x=1,w=null,M=Tl,T=null,A=eh,S=.5;function E(t){return c(t[0]*mf,t[1]*mf)}function N(t){return(t=c.invert(t[0],t[1]))&&[t[0]*bf,t[1]*bf]}function k(){var t=gd(l,0,0,m,x,b).apply(null,n(p,g)),r=gd(l,h-t[0],d-t[1],m,x,b);return e=ul(y,v,_),u=ol(n,r),c=ol(e,u),a=dd(u,S),C()}function C(){return f=s=null,E}return E.stream=function(t){return f&&s===t?f:f=pd(function(t){return id({point:function(n,e){var r=t(n,e);return this.stream.point(r[0],r[1])}})}(e)(M(a(A(s=t)))))},E.preclip=function(t){return arguments.length?(M=t,w=void 0,C()):M},E.postclip=function(t){return arguments.length?(A=t,T=r=i=o=null,C()):A},E.clipAngle=function(t){return arguments.length?(M=+t?Al(w=t*mf):(w=null,Tl),C()):w*bf},E.clipExtent=function(t){return arguments.length?(A=null==t?(T=r=i=o=null,eh):zl(T=+t[0][0],r=+t[0][1],i=+t[1][0],o=+t[1][1]),C()):null==T?null:[[T,r],[i,o]]},E.scale=function(t){return arguments.length?(l=+t,k()):l},E.translate=function(t){return arguments.length?(h=+t[0],d=+t[1],k()):[h,d]},E.center=function(t){return arguments.length?(p=t[0]%360*mf,g=t[1]%360*mf,k()):[p*bf,g*bf]},E.rotate=function(t){return arguments.length?(y=t[0]%360*mf,v=t[1]%360*mf,_=t.length>2?t[2]%360*mf:0,k()):[y*bf,v*bf,_*bf]},E.angle=function(t){return arguments.length?(b=t%360*mf,k()):b*bf},E.reflectX=function(t){return arguments.length?(m=t?-1:1,k()):m<0},E.reflectY=function(t){return arguments.length?(x=t?-1:1,k()):x<0},E.precision=function(t){return arguments.length?(a=dd(u,S=t*t),C()):zf(S)},E.fitExtent=function(t,n){return ud(E,t,n)},E.fitSize=function(t,n){return cd(E,t,n)},E.fitWidth=function(t,n){return fd(E,t,n)},E.fitHeight=function(t,n){return sd(E,t,n)},function(){return n=t.apply(this,arguments),E.invert=n.invert&&N,k()}}function _d(t){var n=0,e=gf/3,r=vd(t),i=r(n,e);return i.parallels=function(t){return arguments.length?r(n=t[0]*mf,e=t[1]*mf):[n*bf,e*bf]},i}function bd(t,n){var e=Cf(t),r=(e+Cf(n))/2;if(xf(r)<df)return function(t){var n=Tf(t);function e(t,e){return[t*n,Cf(e)/n]}return e.invert=function(t,e){return[t/n,Rf(e*n)]},e}(t);var i=1+e*(2*r-e),o=zf(i)/r;function a(t,n){var e=zf(i-2*r*Cf(n))/r;return[e*Cf(t*=r),o-e*Tf(t)]}return a.invert=function(t,n){var e=o-n,a=Mf(t,xf(e))*Pf(e);return e*r<0&&(a-=gf*Pf(t)*Pf(e)),[a/r,Rf((i-(t*t+e*e)*r*r)/(2*r))]},a}function md(){return _d(bd).scale(155.424).center([0,33.6442])}function xd(){return md().parallels([29.5,45.5]).scale(1070).translate([480,250]).rotate([96,0]).center([-.6,38.7])}function wd(t){return function(n,e){var r=Tf(n),i=Tf(e),o=t(r*i);return o===1/0?[2,0]:[o*i*Cf(n),o*Cf(e)]}}function Md(t){return function(n,e){var r=zf(n*n+e*e),i=t(r),o=Cf(i),a=Tf(i);return[Mf(n*o,r*a),Rf(r&&e*o/r)]}}var Td=wd((function(t){return zf(2/(1+t))}));Td.invert=Md((function(t){return 2*Rf(t/2)}));var Ad=wd((function(t){return(t=Df(t))&&t/Cf(t)}));function Sd(t,n){return[t,Nf($f((yf+n)/2))]}function Ed(t){var n,e,r,i=yd(t),o=i.center,a=i.scale,u=i.translate,c=i.clipExtent,f=null;function s(){var o=gf*a(),u=i(ll(i.rotate()).invert([0,0]));return c(null==f?[[u[0]-o,u[1]-o],[u[0]+o,u[1]+o]]:t===Sd?[[Math.max(u[0]-o,f),n],[Math.min(u[0]+o,e),r]]:[[f,Math.max(u[1]-o,n)],[e,Math.min(u[1]+o,r)]])}return i.scale=function(t){return arguments.length?(a(t),s()):a()},i.translate=function(t){return arguments.length?(u(t),s()):u()},i.center=function(t){return arguments.length?(o(t),s()):o()},i.clipExtent=function(t){return arguments.length?(null==t?f=n=e=r=null:(f=+t[0][0],n=+t[0][1],e=+t[1][0],r=+t[1][1]),s()):null==f?null:[[f,n],[e,r]]},s()}function Nd(t){return $f((yf+t)/2)}function kd(t,n){var e=Tf(t),r=t===n?Cf(t):Nf(e/Tf(n))/Nf(Nd(n)/Nd(t)),i=e*kf(Nd(t),r)/r;if(!r)return Sd;function o(t,n){i>0?n<-yf+df&&(n=-yf+df):n>yf-df&&(n=yf-df);var e=i/kf(Nd(n),r);return[e*Cf(r*t),i-e*Tf(r*t)]}return o.invert=function(t,n){var e=i-n,o=Pf(r)*zf(t*t+e*e),a=Mf(t,xf(e))*Pf(e);return e*r<0&&(a-=gf*Pf(t)*Pf(e)),[a/r,2*wf(kf(i/o,1/r))-yf]},o}function Cd(t,n){return[t,n]}function Pd(t,n){var e=Tf(t),r=t===n?Cf(t):(e-Tf(n))/(n-t),i=e/r+t;if(xf(r)<df)return Cd;function o(t,n){var e=i-n,o=r*t;return[e*Cf(o),i-e*Tf(o)]}return o.invert=function(t,n){var e=i-n,o=Mf(t,xf(e))*Pf(e);return e*r<0&&(o-=gf*Pf(t)*Pf(e)),[o/r,i-Pf(r)*zf(t*t+e*e)]},o}Ad.invert=Md((function(t){return t})),Sd.invert=function(t,n){return[t,2*wf(Sf(n))-yf]},Cd.invert=Cd;var zd=1.340264,$d=-.081106,Dd=893e-6,Rd=.003796,Fd=zf(3)/2;function qd(t,n){var e=Rf(Fd*Cf(n)),r=e*e,i=r*r*r;return[t*Tf(e)/(Fd*(zd+3*$d*r+i*(7*Dd+9*Rd*r))),e*(zd+$d*r+i*(Dd+Rd*r))]}function Ud(t,n){var e=Tf(n),r=Tf(t)*e;return[e*Cf(t)/r,Cf(n)/r]}function Id(t,n){var e=n*n,r=e*e;return[t*(.8707-.131979*e+r*(r*(.003971*e-.001529*r)-.013791)),n*(1.007226+e*(.015085+r*(.028874*e-.044475-.005916*r)))]}function Od(t,n){return[Tf(n)*Cf(t),Cf(n)]}function Bd(t,n){var e=Tf(n),r=1+Tf(t)*e;return[e*Cf(t)/r,Cf(n)/r]}function Yd(t,n){return[Nf($f((yf+n)/2)),-t]}function Ld(t,n){return t.parent===n.parent?1:2}function jd(t,n){return t+n.x}function Hd(t,n){return Math.max(t,n.y)}function Xd(t){var n=0,e=t.children,r=e&&e.length;if(r)for(;--r>=0;)n+=e[r].value;else n=1;t.value=n}function Gd(t,n){t instanceof Map?(t=[void 0,t],void 0===n&&(n=Wd)):void 0===n&&(n=Vd);for(var e,r,i,o,a,u=new Qd(t),c=[u];e=c.pop();)if((i=n(e.data))&&(a=(i=Array.from(i)).length))for(e.children=i,o=a-1;o>=0;--o)c.push(r=i[o]=new Qd(i[o])),r.parent=e,r.depth=e.depth+1;return u.eachBefore(Kd)}function Vd(t){return t.children}function Wd(t){return Array.isArray(t)?t[1]:null}function Zd(t){void 0!==t.data.value&&(t.value=t.data.value),t.data=t.data.data}function Kd(t){var n=0;do{t.height=n}while((t=t.parent)&&t.height<++n)}function Qd(t){this.data=t,this.depth=this.height=0,this.parent=null}function Jd(t){return null==t?null:tp(t)}function tp(t){if("function"!=typeof t)throw new Error;return t}function np(){return 0}function ep(t){return function(){return t}}qd.invert=function(t,n){for(var e,r=n,i=r*r,o=i*i*i,a=0;a<12&&(o=(i=(r-=e=(r*(zd+$d*i+o*(Dd+Rd*i))-n)/(zd+3*$d*i+o*(7*Dd+9*Rd*i)))*r)*i*i,!(xf(e)<pf));++a);return[Fd*t*(zd+3*$d*i+o*(7*Dd+9*Rd*i))/Tf(r),Rf(Cf(r)/Fd)]},Ud.invert=Md(wf),Id.invert=function(t,n){var e,r=n,i=25;do{var o=r*r,a=o*o;r-=e=(r*(1.007226+o*(.015085+a*(.028874*o-.044475-.005916*a)))-n)/(1.007226+o*(.045255+a*(.259866*o-.311325-.005916*11*a)))}while(xf(e)>df&&--i>0);return[t/(.8707+(o=r*r)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),r]},Od.invert=Md(Rf),Bd.invert=Md((function(t){return 2*wf(t)})),Yd.invert=function(t,n){return[-n,2*wf(Sf(t))-yf]},Qd.prototype=Gd.prototype={constructor:Qd,count:function(){return this.eachAfter(Xd)},each:function(t,n){let e=-1;for(const r of this)t.call(n,r,++e,this);return this},eachAfter:function(t,n){for(var e,r,i,o=this,a=[o],u=[],c=-1;o=a.pop();)if(u.push(o),e=o.children)for(r=0,i=e.length;r<i;++r)a.push(e[r]);for(;o=u.pop();)t.call(n,o,++c,this);return this},eachBefore:function(t,n){for(var e,r,i=this,o=[i],a=-1;i=o.pop();)if(t.call(n,i,++a,this),e=i.children)for(r=e.length-1;r>=0;--r)o.push(e[r]);return this},find:function(t,n){let e=-1;for(const r of this)if(t.call(n,r,++e,this))return r},sum:function(t){return this.eachAfter((function(n){for(var e=+t(n.data)||0,r=n.children,i=r&&r.length;--i>=0;)e+=r[i].value;n.value=e}))},sort:function(t){return this.eachBefore((function(n){n.children&&n.children.sort(t)}))},path:function(t){for(var n=this,e=function(t,n){if(t===n)return t;var e=t.ancestors(),r=n.ancestors(),i=null;t=e.pop(),n=r.pop();for(;t===n;)i=t,t=e.pop(),n=r.pop();return i}(n,t),r=[n];n!==e;)n=n.parent,r.push(n);for(var i=r.length;t!==e;)r.splice(i,0,t),t=t.parent;return r},ancestors:function(){for(var t=this,n=[t];t=t.parent;)n.push(t);return n},descendants:function(){return Array.from(this)},leaves:function(){var t=[];return this.eachBefore((function(n){n.children||t.push(n)})),t},links:function(){var t=this,n=[];return t.each((function(e){e!==t&&n.push({source:e.parent,target:e})})),n},copy:function(){return Gd(this).eachBefore(Zd)},[Symbol.iterator]:function*(){var t,n,e,r,i=this,o=[i];do{for(t=o.reverse(),o=[];i=t.pop();)if(yield i,n=i.children)for(e=0,r=n.length;e<r;++e)o.push(n[e])}while(o.length)}};const rp=1664525,ip=1013904223,op=4294967296;function ap(){let t=1;return()=>(t=(rp*t+ip)%op)/op}function up(t,n){for(var e,r,i=0,o=(t=function(t,n){let e,r,i=t.length;for(;i;)r=n()*i--|0,e=t[i],t[i]=t[r],t[r]=e;return t}(Array.from(t),n)).length,a=[];i<o;)e=t[i],r&&sp(r,e)?++i:(r=hp(a=cp(a,e)),i=0);return r}function cp(t,n){var e,r;if(lp(n,t))return[n];for(e=0;e<t.length;++e)if(fp(n,t[e])&&lp(dp(t[e],n),t))return[t[e],n];for(e=0;e<t.length-1;++e)for(r=e+1;r<t.length;++r)if(fp(dp(t[e],t[r]),n)&&fp(dp(t[e],n),t[r])&&fp(dp(t[r],n),t[e])&&lp(pp(t[e],t[r],n),t))return[t[e],t[r],n];throw new Error}function fp(t,n){var e=t.r-n.r,r=n.x-t.x,i=n.y-t.y;return e<0||e*e<r*r+i*i}function sp(t,n){var e=t.r-n.r+1e-9*Math.max(t.r,n.r,1),r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function lp(t,n){for(var e=0;e<n.length;++e)if(!sp(t,n[e]))return!1;return!0}function hp(t){switch(t.length){case 1:return function(t){return{x:t.x,y:t.y,r:t.r}}(t[0]);case 2:return dp(t[0],t[1]);case 3:return pp(t[0],t[1],t[2])}}function dp(t,n){var e=t.x,r=t.y,i=t.r,o=n.x,a=n.y,u=n.r,c=o-e,f=a-r,s=u-i,l=Math.sqrt(c*c+f*f);return{x:(e+o+c/l*s)/2,y:(r+a+f/l*s)/2,r:(l+i+u)/2}}function pp(t,n,e){var r=t.x,i=t.y,o=t.r,a=n.x,u=n.y,c=n.r,f=e.x,s=e.y,l=e.r,h=r-a,d=r-f,p=i-u,g=i-s,y=c-o,v=l-o,_=r*r+i*i-o*o,b=_-a*a-u*u+c*c,m=_-f*f-s*s+l*l,x=d*p-h*g,w=(p*m-g*b)/(2*x)-r,M=(g*y-p*v)/x,T=(d*b-h*m)/(2*x)-i,A=(h*v-d*y)/x,S=M*M+A*A-1,E=2*(o+w*M+T*A),N=w*w+T*T-o*o,k=-(Math.abs(S)>1e-6?(E+Math.sqrt(E*E-4*S*N))/(2*S):N/E);return{x:r+w+M*k,y:i+T+A*k,r:k}}function gp(t,n,e){var r,i,o,a,u=t.x-n.x,c=t.y-n.y,f=u*u+c*c;f?(i=n.r+e.r,i*=i,a=t.r+e.r,i>(a*=a)?(r=(f+a-i)/(2*f),o=Math.sqrt(Math.max(0,a/f-r*r)),e.x=t.x-r*u-o*c,e.y=t.y-r*c+o*u):(r=(f+i-a)/(2*f),o=Math.sqrt(Math.max(0,i/f-r*r)),e.x=n.x+r*u-o*c,e.y=n.y+r*c+o*u)):(e.x=n.x+e.r,e.y=n.y)}function yp(t,n){var e=t.r+n.r-1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function vp(t){var n=t._,e=t.next._,r=n.r+e.r,i=(n.x*e.r+e.x*n.r)/r,o=(n.y*e.r+e.y*n.r)/r;return i*i+o*o}function _p(t){this._=t,this.next=null,this.previous=null}function bp(t,n){if(!(o=(t=function(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}(t)).length))return 0;var e,r,i,o,a,u,c,f,s,l,h;if((e=t[0]).x=0,e.y=0,!(o>1))return e.r;if(r=t[1],e.x=-r.r,r.x=e.r,r.y=0,!(o>2))return e.r+r.r;gp(r,e,i=t[2]),e=new _p(e),r=new _p(r),i=new _p(i),e.next=i.previous=r,r.next=e.previous=i,i.next=r.previous=e;t:for(c=3;c<o;++c){gp(e._,r._,i=t[c]),i=new _p(i),f=r.next,s=e.previous,l=r._.r,h=e._.r;do{if(l<=h){if(yp(f._,i._)){r=f,e.next=r,r.previous=e,--c;continue t}l+=f._.r,f=f.next}else{if(yp(s._,i._)){(e=s).next=r,r.previous=e,--c;continue t}h+=s._.r,s=s.previous}}while(f!==s.next);for(i.previous=e,i.next=r,e.next=r.previous=r=i,a=vp(e);(i=i.next)!==r;)(u=vp(i))<a&&(e=i,a=u);r=e.next}for(e=[r._],i=r;(i=i.next)!==r;)e.push(i._);for(i=up(e,n),c=0;c<o;++c)(e=t[c]).x-=i.x,e.y-=i.y;return i.r}function mp(t){return Math.sqrt(t.value)}function xp(t){return function(n){n.children||(n.r=Math.max(0,+t(n)||0))}}function wp(t,n,e){return function(r){if(i=r.children){var i,o,a,u=i.length,c=t(r)*n||0;if(c)for(o=0;o<u;++o)i[o].r+=c;if(a=bp(i,e),c)for(o=0;o<u;++o)i[o].r-=c;r.r=a+c}}}function Mp(t){return function(n){var e=n.parent;n.r*=t,e&&(n.x=e.x+t*n.x,n.y=e.y+t*n.y)}}function Tp(t){t.x0=Math.round(t.x0),t.y0=Math.round(t.y0),t.x1=Math.round(t.x1),t.y1=Math.round(t.y1)}function Ap(t,n,e,r,i){for(var o,a=t.children,u=-1,c=a.length,f=t.value&&(r-n)/t.value;++u<c;)(o=a[u]).y0=e,o.y1=i,o.x0=n,o.x1=n+=o.value*f}var Sp={depth:-1},Ep={},Np={};function kp(t){return t.id}function Cp(t){return t.parentId}function Pp(t){let n=t.length;if(n<2)return"";for(;--n>1&&!zp(t,n););return t.slice(0,n)}function zp(t,n){if("/"===t[n]){let e=0;for(;n>0&&"\\"===t[--n];)++e;if(!(1&e))return!0}return!1}function $p(t,n){return t.parent===n.parent?1:2}function Dp(t){var n=t.children;return n?n[0]:t.t}function Rp(t){var n=t.children;return n?n[n.length-1]:t.t}function Fp(t,n,e){var r=e/(n.i-t.i);n.c-=r,n.s+=e,t.c+=r,n.z+=e,n.m+=e}function qp(t,n,e){return t.a.parent===n.parent?t.a:e}function Up(t,n){this._=t,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=n}function Ip(t,n,e,r,i){for(var o,a=t.children,u=-1,c=a.length,f=t.value&&(i-e)/t.value;++u<c;)(o=a[u]).x0=n,o.x1=r,o.y0=e,o.y1=e+=o.value*f}Up.prototype=Object.create(Qd.prototype);var Op=(1+Math.sqrt(5))/2;function Bp(t,n,e,r,i,o){for(var a,u,c,f,s,l,h,d,p,g,y,v=[],_=n.children,b=0,m=0,x=_.length,w=n.value;b<x;){c=i-e,f=o-r;do{s=_[m++].value}while(!s&&m<x);for(l=h=s,y=s*s*(g=Math.max(f/c,c/f)/(w*t)),p=Math.max(h/y,y/l);m<x;++m){if(s+=u=_[m].value,u<l&&(l=u),u>h&&(h=u),y=s*s*g,(d=Math.max(h/y,y/l))>p){s-=u;break}p=d}v.push(a={value:s,dice:c<f,children:_.slice(b,m)}),a.dice?Ap(a,e,r,i,w?r+=f*s/w:o):Ip(a,e,r,w?e+=c*s/w:i,o),w-=s,b=m}return v}var Yp=function t(n){function e(t,e,r,i,o){Bp(n,t,e,r,i,o)}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}(Op);var Lp=function t(n){function e(t,e,r,i,o){if((a=t._squarify)&&a.ratio===n)for(var a,u,c,f,s,l=-1,h=a.length,d=t.value;++l<h;){for(c=(u=a[l]).children,f=u.value=0,s=c.length;f<s;++f)u.value+=c[f].value;u.dice?Ap(u,e,r,i,d?r+=(o-r)*u.value/d:o):Ip(u,e,r,d?e+=(i-e)*u.value/d:i,o),d-=u.value}else t._squarify=a=Bp(n,t,e,r,i,o),a.ratio=n}return e.ratio=function(n){return t((n=+n)>1?n:1)},e}(Op);function jp(t,n,e){return(n[0]-t[0])*(e[1]-t[1])-(n[1]-t[1])*(e[0]-t[0])}function Hp(t,n){return t[0]-n[0]||t[1]-n[1]}function Xp(t){const n=t.length,e=[0,1];let r,i=2;for(r=2;r<n;++r){for(;i>1&&jp(t[e[i-2]],t[e[i-1]],t[r])<=0;)--i;e[i++]=r}return e.slice(0,i)}var Gp=Math.random,Vp=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,1===arguments.length?(e=t,t=0):e-=t,function(){return n()*e+t}}return e.source=t,e}(Gp),Wp=function t(n){function e(t,e){return arguments.length<2&&(e=t,t=0),t=Math.floor(t),e=Math.floor(e)-t,function(){return Math.floor(n()*e+t)}}return e.source=t,e}(Gp),Zp=function t(n){function e(t,e){var r,i;return t=null==t?0:+t,e=null==e?1:+e,function(){var o;if(null!=r)o=r,r=null;else do{r=2*n()-1,o=2*n()-1,i=r*r+o*o}while(!i||i>1);return t+e*o*Math.sqrt(-2*Math.log(i)/i)}}return e.source=t,e}(Gp),Kp=function t(n){var e=Zp.source(n);function r(){var t=e.apply(this,arguments);return function(){return Math.exp(t())}}return r.source=t,r}(Gp),Qp=function t(n){function e(t){return(t=+t)<=0?()=>0:function(){for(var e=0,r=t;r>1;--r)e+=n();return e+r*n()}}return e.source=t,e}(Gp),Jp=function t(n){var e=Qp.source(n);function r(t){if(0==(t=+t))return n;var r=e(t);return function(){return r()/t}}return r.source=t,r}(Gp),tg=function t(n){function e(t){return function(){return-Math.log1p(-n())/t}}return e.source=t,e}(Gp),ng=function t(n){function e(t){if((t=+t)<0)throw new RangeError("invalid alpha");return t=1/-t,function(){return Math.pow(1-n(),t)}}return e.source=t,e}(Gp),eg=function t(n){function e(t){if((t=+t)<0||t>1)throw new RangeError("invalid p");return function(){return Math.floor(n()+t)}}return e.source=t,e}(Gp),rg=function t(n){function e(t){if((t=+t)<0||t>1)throw new RangeError("invalid p");return 0===t?()=>1/0:1===t?()=>1:(t=Math.log1p(-t),function(){return 1+Math.floor(Math.log1p(-n())/t)})}return e.source=t,e}(Gp),ig=function t(n){var e=Zp.source(n)();function r(t,r){if((t=+t)<0)throw new RangeError("invalid k");if(0===t)return()=>0;if(r=null==r?1:+r,1===t)return()=>-Math.log1p(-n())*r;var i=(t<1?t+1:t)-1/3,o=1/(3*Math.sqrt(i)),a=t<1?()=>Math.pow(n(),1/t):()=>1;return function(){do{do{var t=e(),u=1+o*t}while(u<=0);u*=u*u;var c=1-n()}while(c>=1-.0331*t*t*t*t&&Math.log(c)>=.5*t*t+i*(1-u+Math.log(u)));return i*u*a()*r}}return r.source=t,r}(Gp),og=function t(n){var e=ig.source(n);function r(t,n){var r=e(t),i=e(n);return function(){var t=r();return 0===t?0:t/(t+i())}}return r.source=t,r}(Gp),ag=function t(n){var e=rg.source(n),r=og.source(n);function i(t,n){return t=+t,(n=+n)>=1?()=>t:n<=0?()=>0:function(){for(var i=0,o=t,a=n;o*a>16&&o*(1-a)>16;){var u=Math.floor((o+1)*a),c=r(u,o-u+1)();c<=a?(i+=u,o-=u,a=(a-c)/(1-c)):(o=u-1,a/=c)}for(var f=a<.5,s=e(f?a:1-a),l=s(),h=0;l<=o;++h)l+=s();return i+(f?h:o-h)}}return i.source=t,i}(Gp),ug=function t(n){function e(t,e,r){var i;return 0==(t=+t)?i=t=>-Math.log(t):(t=1/t,i=n=>Math.pow(n,t)),e=null==e?0:+e,r=null==r?1:+r,function(){return e+r*i(-Math.log1p(-n()))}}return e.source=t,e}(Gp),cg=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,function(){return t+e*Math.tan(Math.PI*n())}}return e.source=t,e}(Gp),fg=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,function(){var r=n();return t+e*Math.log(r/(1-r))}}return e.source=t,e}(Gp),sg=function t(n){var e=ig.source(n),r=ag.source(n);function i(t){return function(){for(var i=0,o=t;o>16;){var a=Math.floor(.875*o),u=e(a)();if(u>o)return i+r(a-1,o/u)();i+=a,o-=u}for(var c=-Math.log1p(-n()),f=0;c<=o;++f)c-=Math.log1p(-n());return i+f}}return i.source=t,i}(Gp);const lg=1/4294967296;function hg(t,n){switch(arguments.length){case 0:break;case 1:this.range(t);break;default:this.range(n).domain(t)}return this}function dg(t,n){switch(arguments.length){case 0:break;case 1:"function"==typeof t?this.interpolator(t):this.range(t);break;default:this.domain(t),"function"==typeof n?this.interpolator(n):this.range(n)}return this}const pg=Symbol("implicit");function gg(){var t=new InternMap,n=[],e=[],r=pg;function i(i){let o=t.get(i);if(void 0===o){if(r!==pg)return r;t.set(i,o=n.push(i)-1)}return e[o%e.length]}return i.domain=function(e){if(!arguments.length)return n.slice();n=[],t=new InternMap;for(const r of e)t.has(r)||t.set(r,n.push(r)-1);return i},i.range=function(t){return arguments.length?(e=Array.from(t),i):e.slice()},i.unknown=function(t){return arguments.length?(r=t,i):r},i.copy=function(){return gg(n,e).unknown(r)},hg.apply(i,arguments),i}function yg(){var t,n,e=gg().unknown(void 0),r=e.domain,i=e.range,o=0,a=1,u=!1,c=0,f=0,s=.5;function l(){var e=r().length,l=a<o,h=l?a:o,d=l?o:a;t=(d-h)/Math.max(1,e-c+2*f),u&&(t=Math.floor(t)),h+=(d-h-t*(e-c))*s,n=t*(1-c),u&&(h=Math.round(h),n=Math.round(n));var p=lt(e).map((function(n){return h+t*n}));return i(l?p.reverse():p)}return delete e.unknown,e.domain=function(t){return arguments.length?(r(t),l()):r()},e.range=function(t){return arguments.length?([o,a]=t,o=+o,a=+a,l()):[o,a]},e.rangeRound=function(t){return[o,a]=t,o=+o,a=+a,u=!0,l()},e.bandwidth=function(){return n},e.step=function(){return t},e.round=function(t){return arguments.length?(u=!!t,l()):u},e.padding=function(t){return arguments.length?(c=Math.min(1,f=+t),l()):c},e.paddingInner=function(t){return arguments.length?(c=Math.min(1,t),l()):c},e.paddingOuter=function(t){return arguments.length?(f=+t,l()):f},e.align=function(t){return arguments.length?(s=Math.max(0,Math.min(1,t)),l()):s},e.copy=function(){return yg(r(),[o,a]).round(u).paddingInner(c).paddingOuter(f).align(s)},hg.apply(l(),arguments)}function vg(t){var n=t.copy;return t.padding=t.paddingOuter,delete t.paddingInner,delete t.paddingOuter,t.copy=function(){return vg(n())},t}function _g(t){return+t}var bg=[0,1];function mg(t){return t}function xg(t,n){return(n-=t=+t)?function(e){return(e-t)/n}:function(t){return function(){return t}}(isNaN(n)?NaN:.5)}function wg(t,n,e){var r=t[0],i=t[1],o=n[0],a=n[1];return i<r?(r=xg(i,r),o=e(a,o)):(r=xg(r,i),o=e(o,a)),function(t){return o(r(t))}}function Mg(t,n,e){var r=Math.min(t.length,n.length)-1,i=new Array(r),o=new Array(r),a=-1;for(t[r]<t[0]&&(t=t.slice().reverse(),n=n.slice().reverse());++a<r;)i[a]=xg(t[a],t[a+1]),o[a]=e(n[a],n[a+1]);return function(n){var e=s(t,n,1,r)-1;return o[e](i[e](n))}}function Tg(t,n){return n.domain(t.domain()).range(t.range()).interpolate(t.interpolate()).clamp(t.clamp()).unknown(t.unknown())}function Ag(){var t,n,e,r,i,o,a=bg,u=bg,c=Gr,f=mg;function s(){var t=Math.min(a.length,u.length);return f!==mg&&(f=function(t,n){var e;return t>n&&(e=t,t=n,n=e),function(e){return Math.max(t,Math.min(n,e))}}(a[0],a[t-1])),r=t>2?Mg:wg,i=o=null,l}function l(n){return null==n||isNaN(n=+n)?e:(i||(i=r(a.map(t),u,c)))(t(f(n)))}return l.invert=function(e){return f(n((o||(o=r(u,a.map(t),Yr)))(e)))},l.domain=function(t){return arguments.length?(a=Array.from(t,_g),s()):a.slice()},l.range=function(t){return arguments.length?(u=Array.from(t),s()):u.slice()},l.rangeRound=function(t){return u=Array.from(t),c=Vr,s()},l.clamp=function(t){return arguments.length?(f=!!t||mg,s()):f!==mg},l.interpolate=function(t){return arguments.length?(c=t,s()):c},l.unknown=function(t){return arguments.length?(e=t,l):e},function(e,r){return t=e,n=r,s()}}function Sg(){return Ag()(mg,mg)}function Eg(n,e,r,i){var o,a=W(n,e,r);switch((i=Jc(null==i?",f":i)).type){case"s":var u=Math.max(Math.abs(n),Math.abs(e));return null!=i.precision||isNaN(o=lf(a,u))||(i.precision=o),t.formatPrefix(i,u);case"":case"e":case"g":case"p":case"r":null!=i.precision||isNaN(o=hf(a,Math.max(Math.abs(n),Math.abs(e))))||(i.precision=o-("e"===i.type));break;case"f":case"%":null!=i.precision||isNaN(o=sf(a))||(i.precision=o-2*("%"===i.type))}return t.format(i)}function Ng(t){var n=t.domain;return t.ticks=function(t){var e=n();return G(e[0],e[e.length-1],null==t?10:t)},t.tickFormat=function(t,e){var r=n();return Eg(r[0],r[r.length-1],null==t?10:t,e)},t.nice=function(e){null==e&&(e=10);var r,i,o=n(),a=0,u=o.length-1,c=o[a],f=o[u],s=10;for(f<c&&(i=c,c=f,f=i,i=a,a=u,u=i);s-- >0;){if((i=V(c,f,e))===r)return o[a]=c,o[u]=f,n(o);if(i>0)c=Math.floor(c/i)*i,f=Math.ceil(f/i)*i;else{if(!(i<0))break;c=Math.ceil(c*i)/i,f=Math.floor(f*i)/i}r=i}return t},t}function kg(t,n){var e,r=0,i=(t=t.slice()).length-1,o=t[r],a=t[i];return a<o&&(e=r,r=i,i=e,e=o,o=a,a=e),t[r]=n.floor(o),t[i]=n.ceil(a),t}function Cg(t){return Math.log(t)}function Pg(t){return Math.exp(t)}function zg(t){return-Math.log(-t)}function $g(t){return-Math.exp(-t)}function Dg(t){return isFinite(t)?+("1e"+t):t<0?0:t}function Rg(t){return(n,e)=>-t(-n,e)}function Fg(n){const e=n(Cg,Pg),r=e.domain;let i,o,a=10;function u(){return i=function(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),n=>Math.log(n)/t)}(a),o=function(t){return 10===t?Dg:t===Math.E?Math.exp:n=>Math.pow(t,n)}(a),r()[0]<0?(i=Rg(i),o=Rg(o),n(zg,$g)):n(Cg,Pg),e}return e.base=function(t){return arguments.length?(a=+t,u()):a},e.domain=function(t){return arguments.length?(r(t),u()):r()},e.ticks=t=>{const n=r();let e=n[0],u=n[n.length-1];const c=u<e;c&&([e,u]=[u,e]);let f,s,l=i(e),h=i(u);const d=null==t?10:+t;let p=[];if(!(a%1)&&h-l<d){if(l=Math.floor(l),h=Math.ceil(h),e>0){for(;l<=h;++l)for(f=1;f<a;++f)if(s=l<0?f/o(-l):f*o(l),!(s<e)){if(s>u)break;p.push(s)}}else for(;l<=h;++l)for(f=a-1;f>=1;--f)if(s=l>0?f/o(-l):f*o(l),!(s<e)){if(s>u)break;p.push(s)}2*p.length<d&&(p=G(e,u,d))}else p=G(l,h,Math.min(h-l,d)).map(o);return c?p.reverse():p},e.tickFormat=(n,r)=>{if(null==n&&(n=10),null==r&&(r=10===a?"s":","),"function"!=typeof r&&(a%1||null!=(r=Jc(r)).precision||(r.trim=!0),r=t.format(r)),n===1/0)return r;const u=Math.max(1,a*n/e.ticks().length);return t=>{let n=t/o(Math.round(i(t)));return n*a<a-.5&&(n*=a),n<=u?r(t):""}},e.nice=()=>r(kg(r(),{floor:t=>o(Math.floor(i(t))),ceil:t=>o(Math.ceil(i(t)))})),e}function qg(t){return function(n){return Math.sign(n)*Math.log1p(Math.abs(n/t))}}function Ug(t){return function(n){return Math.sign(n)*Math.expm1(Math.abs(n))*t}}function Ig(t){var n=1,e=t(qg(n),Ug(n));return e.constant=function(e){return arguments.length?t(qg(n=+e),Ug(n)):n},Ng(e)}function Og(t){return function(n){return n<0?-Math.pow(-n,t):Math.pow(n,t)}}function Bg(t){return t<0?-Math.sqrt(-t):Math.sqrt(t)}function Yg(t){return t<0?-t*t:t*t}function Lg(t){var n=t(mg,mg),e=1;return n.exponent=function(n){return arguments.length?1===(e=+n)?t(mg,mg):.5===e?t(Bg,Yg):t(Og(e),Og(1/e)):e},Ng(n)}function jg(){var t=Lg(Ag());return t.copy=function(){return Tg(t,jg()).exponent(t.exponent())},hg.apply(t,arguments),t}function Hg(t){return Math.sign(t)*t*t}const Xg=new Date,Gg=new Date;function Vg(t,n,e,r){function i(n){return t(n=0===arguments.length?new Date:new Date(+n)),n}return i.floor=n=>(t(n=new Date(+n)),n),i.ceil=e=>(t(e=new Date(e-1)),n(e,1),t(e),e),i.round=t=>{const n=i(t),e=i.ceil(t);return t-n<e-t?n:e},i.offset=(t,e)=>(n(t=new Date(+t),null==e?1:Math.floor(e)),t),i.range=(e,r,o)=>{const a=[];if(e=i.ceil(e),o=null==o?1:Math.floor(o),!(e<r&&o>0))return a;let u;do{a.push(u=new Date(+e)),n(e,o),t(e)}while(u<e&&e<r);return a},i.filter=e=>Vg((n=>{if(n>=n)for(;t(n),!e(n);)n.setTime(n-1)}),((t,r)=>{if(t>=t)if(r<0)for(;++r<=0;)for(;n(t,-1),!e(t););else for(;--r>=0;)for(;n(t,1),!e(t););})),e&&(i.count=(n,r)=>(Xg.setTime(+n),Gg.setTime(+r),t(Xg),t(Gg),Math.floor(e(Xg,Gg))),i.every=t=>(t=Math.floor(t),isFinite(t)&&t>0?t>1?i.filter(r?n=>r(n)%t==0:n=>i.count(0,n)%t==0):i:null)),i}const Wg=Vg((()=>{}),((t,n)=>{t.setTime(+t+n)}),((t,n)=>n-t));Wg.every=t=>(t=Math.floor(t),isFinite(t)&&t>0?t>1?Vg((n=>{n.setTime(Math.floor(n/t)*t)}),((n,e)=>{n.setTime(+n+e*t)}),((n,e)=>(e-n)/t)):Wg:null);const Zg=Wg.range,Kg=1e3,Qg=6e4,Jg=36e5,ty=864e5,ny=6048e5,ey=2592e6,ry=31536e6,iy=Vg((t=>{t.setTime(t-t.getMilliseconds())}),((t,n)=>{t.setTime(+t+n*Kg)}),((t,n)=>(n-t)/Kg),(t=>t.getUTCSeconds())),oy=iy.range,ay=Vg((t=>{t.setTime(t-t.getMilliseconds()-t.getSeconds()*Kg)}),((t,n)=>{t.setTime(+t+n*Qg)}),((t,n)=>(n-t)/Qg),(t=>t.getMinutes())),uy=ay.range,cy=Vg((t=>{t.setUTCSeconds(0,0)}),((t,n)=>{t.setTime(+t+n*Qg)}),((t,n)=>(n-t)/Qg),(t=>t.getUTCMinutes())),fy=cy.range,sy=Vg((t=>{t.setTime(t-t.getMilliseconds()-t.getSeconds()*Kg-t.getMinutes()*Qg)}),((t,n)=>{t.setTime(+t+n*Jg)}),((t,n)=>(n-t)/Jg),(t=>t.getHours())),ly=sy.range,hy=Vg((t=>{t.setUTCMinutes(0,0,0)}),((t,n)=>{t.setTime(+t+n*Jg)}),((t,n)=>(n-t)/Jg),(t=>t.getUTCHours())),dy=hy.range,py=Vg((t=>t.setHours(0,0,0,0)),((t,n)=>t.setDate(t.getDate()+n)),((t,n)=>(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Qg)/ty),(t=>t.getDate()-1)),gy=py.range,yy=Vg((t=>{t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCDate(t.getUTCDate()+n)}),((t,n)=>(n-t)/ty),(t=>t.getUTCDate()-1)),vy=yy.range,_y=Vg((t=>{t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCDate(t.getUTCDate()+n)}),((t,n)=>(n-t)/ty),(t=>Math.floor(t/ty))),by=_y.range;function my(t){return Vg((n=>{n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)}),((t,n)=>{t.setDate(t.getDate()+7*n)}),((t,n)=>(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Qg)/ny))}const xy=my(0),wy=my(1),My=my(2),Ty=my(3),Ay=my(4),Sy=my(5),Ey=my(6),Ny=xy.range,ky=wy.range,Cy=My.range,Py=Ty.range,zy=Ay.range,$y=Sy.range,Dy=Ey.range;function Ry(t){return Vg((n=>{n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCDate(t.getUTCDate()+7*n)}),((t,n)=>(n-t)/ny))}const Fy=Ry(0),qy=Ry(1),Uy=Ry(2),Iy=Ry(3),Oy=Ry(4),By=Ry(5),Yy=Ry(6),Ly=Fy.range,jy=qy.range,Hy=Uy.range,Xy=Iy.range,Gy=Oy.range,Vy=By.range,Wy=Yy.range,Zy=Vg((t=>{t.setDate(1),t.setHours(0,0,0,0)}),((t,n)=>{t.setMonth(t.getMonth()+n)}),((t,n)=>n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())),(t=>t.getMonth())),Ky=Zy.range,Qy=Vg((t=>{t.setUTCDate(1),t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCMonth(t.getUTCMonth()+n)}),((t,n)=>n.getUTCMonth()-t.getUTCMonth()+12*(n.getUTCFullYear()-t.getUTCFullYear())),(t=>t.getUTCMonth())),Jy=Qy.range,tv=Vg((t=>{t.setMonth(0,1),t.setHours(0,0,0,0)}),((t,n)=>{t.setFullYear(t.getFullYear()+n)}),((t,n)=>n.getFullYear()-t.getFullYear()),(t=>t.getFullYear()));tv.every=t=>isFinite(t=Math.floor(t))&&t>0?Vg((n=>{n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)}),((n,e)=>{n.setFullYear(n.getFullYear()+e*t)})):null;const nv=tv.range,ev=Vg((t=>{t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCFullYear(t.getUTCFullYear()+n)}),((t,n)=>n.getUTCFullYear()-t.getUTCFullYear()),(t=>t.getUTCFullYear()));ev.every=t=>isFinite(t=Math.floor(t))&&t>0?Vg((n=>{n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)}),((n,e)=>{n.setUTCFullYear(n.getUTCFullYear()+e*t)})):null;const rv=ev.range;function iv(t,n,e,i,o,a){const u=[[iy,1,Kg],[iy,5,5e3],[iy,15,15e3],[iy,30,3e4],[a,1,Qg],[a,5,3e5],[a,15,9e5],[a,30,18e5],[o,1,Jg],[o,3,108e5],[o,6,216e5],[o,12,432e5],[i,1,ty],[i,2,1728e5],[e,1,ny],[n,1,ey],[n,3,7776e6],[t,1,ry]];function c(n,e,i){const o=Math.abs(e-n)/i,a=r((([,,t])=>t)).right(u,o);if(a===u.length)return t.every(W(n/ry,e/ry,i));if(0===a)return Wg.every(Math.max(W(n,e,i),1));const[c,f]=u[o/u[a-1][2]<u[a][2]/o?a-1:a];return c.every(f)}return[function(t,n,e){const r=n<t;r&&([t,n]=[n,t]);const i=e&&"function"==typeof e.range?e:c(t,n,e),o=i?i.range(t,+n+1):[];return r?o.reverse():o},c]}const[ov,av]=iv(ev,Qy,Fy,_y,hy,cy),[uv,cv]=iv(tv,Zy,xy,py,sy,ay);function fv(t){if(0<=t.y&&t.y<100){var n=new Date(-1,t.m,t.d,t.H,t.M,t.S,t.L);return n.setFullYear(t.y),n}return new Date(t.y,t.m,t.d,t.H,t.M,t.S,t.L)}function sv(t){if(0<=t.y&&t.y<100){var n=new Date(Date.UTC(-1,t.m,t.d,t.H,t.M,t.S,t.L));return n.setUTCFullYear(t.y),n}return new Date(Date.UTC(t.y,t.m,t.d,t.H,t.M,t.S,t.L))}function lv(t,n,e){return{y:t,m:n,d:e,H:0,M:0,S:0,L:0}}function hv(t){var n=t.dateTime,e=t.date,r=t.time,i=t.periods,o=t.days,a=t.shortDays,u=t.months,c=t.shortMonths,f=mv(i),s=xv(i),l=mv(o),h=xv(o),d=mv(a),p=xv(a),g=mv(u),y=xv(u),v=mv(c),_=xv(c),b={a:function(t){return a[t.getDay()]},A:function(t){return o[t.getDay()]},b:function(t){return c[t.getMonth()]},B:function(t){return u[t.getMonth()]},c:null,d:Yv,e:Yv,f:Gv,g:i_,G:a_,H:Lv,I:jv,j:Hv,L:Xv,m:Vv,M:Wv,p:function(t){return i[+(t.getHours()>=12)]},q:function(t){return 1+~~(t.getMonth()/3)},Q:k_,s:C_,S:Zv,u:Kv,U:Qv,V:t_,w:n_,W:e_,x:null,X:null,y:r_,Y:o_,Z:u_,"%":N_},m={a:function(t){return a[t.getUTCDay()]},A:function(t){return o[t.getUTCDay()]},b:function(t){return c[t.getUTCMonth()]},B:function(t){return u[t.getUTCMonth()]},c:null,d:c_,e:c_,f:d_,g:T_,G:S_,H:f_,I:s_,j:l_,L:h_,m:p_,M:g_,p:function(t){return i[+(t.getUTCHours()>=12)]},q:function(t){return 1+~~(t.getUTCMonth()/3)},Q:k_,s:C_,S:y_,u:v_,U:__,V:m_,w:x_,W:w_,x:null,X:null,y:M_,Y:A_,Z:E_,"%":N_},x={a:function(t,n,e){var r=d.exec(n.slice(e));return r?(t.w=p.get(r[0].toLowerCase()),e+r[0].length):-1},A:function(t,n,e){var r=l.exec(n.slice(e));return r?(t.w=h.get(r[0].toLowerCase()),e+r[0].length):-1},b:function(t,n,e){var r=v.exec(n.slice(e));return r?(t.m=_.get(r[0].toLowerCase()),e+r[0].length):-1},B:function(t,n,e){var r=g.exec(n.slice(e));return r?(t.m=y.get(r[0].toLowerCase()),e+r[0].length):-1},c:function(t,e,r){return T(t,n,e,r)},d:zv,e:zv,f:Uv,g:Nv,G:Ev,H:Dv,I:Dv,j:$v,L:qv,m:Pv,M:Rv,p:function(t,n,e){var r=f.exec(n.slice(e));return r?(t.p=s.get(r[0].toLowerCase()),e+r[0].length):-1},q:Cv,Q:Ov,s:Bv,S:Fv,u:Mv,U:Tv,V:Av,w:wv,W:Sv,x:function(t,n,r){return T(t,e,n,r)},X:function(t,n,e){return T(t,r,n,e)},y:Nv,Y:Ev,Z:kv,"%":Iv};function w(t,n){return function(e){var r,i,o,a=[],u=-1,c=0,f=t.length;for(e instanceof Date||(e=new Date(+e));++u<f;)37===t.charCodeAt(u)&&(a.push(t.slice(c,u)),null!=(i=pv[r=t.charAt(++u)])?r=t.charAt(++u):i="e"===r?" ":"0",(o=n[r])&&(r=o(e,i)),a.push(r),c=u+1);return a.push(t.slice(c,u)),a.join("")}}function M(t,n){return function(e){var r,i,o=lv(1900,void 0,1);if(T(o,t,e+="",0)!=e.length)return null;if("Q"in o)return new Date(o.Q);if("s"in o)return new Date(1e3*o.s+("L"in o?o.L:0));if(n&&!("Z"in o)&&(o.Z=0),"p"in o&&(o.H=o.H%12+12*o.p),void 0===o.m&&(o.m="q"in o?o.q:0),"V"in o){if(o.V<1||o.V>53)return null;"w"in o||(o.w=1),"Z"in o?(i=(r=sv(lv(o.y,0,1))).getUTCDay(),r=i>4||0===i?qy.ceil(r):qy(r),r=yy.offset(r,7*(o.V-1)),o.y=r.getUTCFullYear(),o.m=r.getUTCMonth(),o.d=r.getUTCDate()+(o.w+6)%7):(i=(r=fv(lv(o.y,0,1))).getDay(),r=i>4||0===i?wy.ceil(r):wy(r),r=py.offset(r,7*(o.V-1)),o.y=r.getFullYear(),o.m=r.getMonth(),o.d=r.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),i="Z"in o?sv(lv(o.y,0,1)).getUTCDay():fv(lv(o.y,0,1)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(i+5)%7:o.w+7*o.U-(i+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,sv(o)):fv(o)}}function T(t,n,e,r){for(var i,o,a=0,u=n.length,c=e.length;a<u;){if(r>=c)return-1;if(37===(i=n.charCodeAt(a++))){if(i=n.charAt(a++),!(o=x[i in pv?n.charAt(a++):i])||(r=o(t,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}return b.x=w(e,b),b.X=w(r,b),b.c=w(n,b),m.x=w(e,m),m.X=w(r,m),m.c=w(n,m),{format:function(t){var n=w(t+="",b);return n.toString=function(){return t},n},parse:function(t){var n=M(t+="",!1);return n.toString=function(){return t},n},utcFormat:function(t){var n=w(t+="",m);return n.toString=function(){return t},n},utcParse:function(t){var n=M(t+="",!0);return n.toString=function(){return t},n}}}var dv,pv={"-":"",_:" ",0:"0"},gv=/^\s*\d+/,yv=/^%/,vv=/[\\^$*+?|[\]().{}]/g;function _v(t,n,e){var r=t<0?"-":"",i=(r?-t:t)+"",o=i.length;return r+(o<e?new Array(e-o+1).join(n)+i:i)}function bv(t){return t.replace(vv,"\\$&")}function mv(t){return new RegExp("^(?:"+t.map(bv).join("|")+")","i")}function xv(t){return new Map(t.map(((t,n)=>[t.toLowerCase(),n])))}function wv(t,n,e){var r=gv.exec(n.slice(e,e+1));return r?(t.w=+r[0],e+r[0].length):-1}function Mv(t,n,e){var r=gv.exec(n.slice(e,e+1));return r?(t.u=+r[0],e+r[0].length):-1}function Tv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.U=+r[0],e+r[0].length):-1}function Av(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.V=+r[0],e+r[0].length):-1}function Sv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.W=+r[0],e+r[0].length):-1}function Ev(t,n,e){var r=gv.exec(n.slice(e,e+4));return r?(t.y=+r[0],e+r[0].length):-1}function Nv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),e+r[0].length):-1}function kv(t,n,e){var r=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(n.slice(e,e+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),e+r[0].length):-1}function Cv(t,n,e){var r=gv.exec(n.slice(e,e+1));return r?(t.q=3*r[0]-3,e+r[0].length):-1}function Pv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.m=r[0]-1,e+r[0].length):-1}function zv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.d=+r[0],e+r[0].length):-1}function $v(t,n,e){var r=gv.exec(n.slice(e,e+3));return r?(t.m=0,t.d=+r[0],e+r[0].length):-1}function Dv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.H=+r[0],e+r[0].length):-1}function Rv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.M=+r[0],e+r[0].length):-1}function Fv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.S=+r[0],e+r[0].length):-1}function qv(t,n,e){var r=gv.exec(n.slice(e,e+3));return r?(t.L=+r[0],e+r[0].length):-1}function Uv(t,n,e){var r=gv.exec(n.slice(e,e+6));return r?(t.L=Math.floor(r[0]/1e3),e+r[0].length):-1}function Iv(t,n,e){var r=yv.exec(n.slice(e,e+1));return r?e+r[0].length:-1}function Ov(t,n,e){var r=gv.exec(n.slice(e));return r?(t.Q=+r[0],e+r[0].length):-1}function Bv(t,n,e){var r=gv.exec(n.slice(e));return r?(t.s=+r[0],e+r[0].length):-1}function Yv(t,n){return _v(t.getDate(),n,2)}function Lv(t,n){return _v(t.getHours(),n,2)}function jv(t,n){return _v(t.getHours()%12||12,n,2)}function Hv(t,n){return _v(1+py.count(tv(t),t),n,3)}function Xv(t,n){return _v(t.getMilliseconds(),n,3)}function Gv(t,n){return Xv(t,n)+"000"}function Vv(t,n){return _v(t.getMonth()+1,n,2)}function Wv(t,n){return _v(t.getMinutes(),n,2)}function Zv(t,n){return _v(t.getSeconds(),n,2)}function Kv(t){var n=t.getDay();return 0===n?7:n}function Qv(t,n){return _v(xy.count(tv(t)-1,t),n,2)}function Jv(t){var n=t.getDay();return n>=4||0===n?Ay(t):Ay.ceil(t)}function t_(t,n){return t=Jv(t),_v(Ay.count(tv(t),t)+(4===tv(t).getDay()),n,2)}function n_(t){return t.getDay()}function e_(t,n){return _v(wy.count(tv(t)-1,t),n,2)}function r_(t,n){return _v(t.getFullYear()%100,n,2)}function i_(t,n){return _v((t=Jv(t)).getFullYear()%100,n,2)}function o_(t,n){return _v(t.getFullYear()%1e4,n,4)}function a_(t,n){var e=t.getDay();return _v((t=e>=4||0===e?Ay(t):Ay.ceil(t)).getFullYear()%1e4,n,4)}function u_(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+_v(n/60|0,"0",2)+_v(n%60,"0",2)}function c_(t,n){return _v(t.getUTCDate(),n,2)}function f_(t,n){return _v(t.getUTCHours(),n,2)}function s_(t,n){return _v(t.getUTCHours()%12||12,n,2)}function l_(t,n){return _v(1+yy.count(ev(t),t),n,3)}function h_(t,n){return _v(t.getUTCMilliseconds(),n,3)}function d_(t,n){return h_(t,n)+"000"}function p_(t,n){return _v(t.getUTCMonth()+1,n,2)}function g_(t,n){return _v(t.getUTCMinutes(),n,2)}function y_(t,n){return _v(t.getUTCSeconds(),n,2)}function v_(t){var n=t.getUTCDay();return 0===n?7:n}function __(t,n){return _v(Fy.count(ev(t)-1,t),n,2)}function b_(t){var n=t.getUTCDay();return n>=4||0===n?Oy(t):Oy.ceil(t)}function m_(t,n){return t=b_(t),_v(Oy.count(ev(t),t)+(4===ev(t).getUTCDay()),n,2)}function x_(t){return t.getUTCDay()}function w_(t,n){return _v(qy.count(ev(t)-1,t),n,2)}function M_(t,n){return _v(t.getUTCFullYear()%100,n,2)}function T_(t,n){return _v((t=b_(t)).getUTCFullYear()%100,n,2)}function A_(t,n){return _v(t.getUTCFullYear()%1e4,n,4)}function S_(t,n){var e=t.getUTCDay();return _v((t=e>=4||0===e?Oy(t):Oy.ceil(t)).getUTCFullYear()%1e4,n,4)}function E_(){return"+0000"}function N_(){return"%"}function k_(t){return+t}function C_(t){return Math.floor(+t/1e3)}function P_(n){return dv=hv(n),t.timeFormat=dv.format,t.timeParse=dv.parse,t.utcFormat=dv.utcFormat,t.utcParse=dv.utcParse,dv}t.timeFormat=void 0,t.timeParse=void 0,t.utcFormat=void 0,t.utcParse=void 0,P_({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var z_="%Y-%m-%dT%H:%M:%S.%LZ";var $_=Date.prototype.toISOString?function(t){return t.toISOString()}:t.utcFormat(z_),D_=$_;var R_=+new Date("2000-01-01T00:00:00.000Z")?function(t){var n=new Date(t);return isNaN(n)?null:n}:t.utcParse(z_),F_=R_;function q_(t){return new Date(t)}function U_(t){return t instanceof Date?+t:+new Date(+t)}function I_(t,n,e,r,i,o,a,u,c,f){var s=Sg(),l=s.invert,h=s.domain,d=f(".%L"),p=f(":%S"),g=f("%I:%M"),y=f("%I %p"),v=f("%a %d"),_=f("%b %d"),b=f("%B"),m=f("%Y");function x(t){return(c(t)<t?d:u(t)<t?p:a(t)<t?g:o(t)<t?y:r(t)<t?i(t)<t?v:_:e(t)<t?b:m)(t)}return s.invert=function(t){return new Date(l(t))},s.domain=function(t){return arguments.length?h(Array.from(t,U_)):h().map(q_)},s.ticks=function(n){var e=h();return t(e[0],e[e.length-1],null==n?10:n)},s.tickFormat=function(t,n){return null==n?x:f(n)},s.nice=function(t){var e=h();return t&&"function"==typeof t.range||(t=n(e[0],e[e.length-1],null==t?10:t)),t?h(kg(e,t)):s},s.copy=function(){return Tg(s,I_(t,n,e,r,i,o,a,u,c,f))},s}function O_(){var t,n,e,r,i,o=0,a=1,u=mg,c=!1;function f(n){return null==n||isNaN(n=+n)?i:u(0===e?.5:(n=(r(n)-t)*e,c?Math.max(0,Math.min(1,n)):n))}function s(t){return function(n){var e,r;return arguments.length?([e,r]=n,u=t(e,r),f):[u(0),u(1)]}}return f.domain=function(i){return arguments.length?([o,a]=i,t=r(o=+o),n=r(a=+a),e=t===n?0:1/(n-t),f):[o,a]},f.clamp=function(t){return arguments.length?(c=!!t,f):c},f.interpolator=function(t){return arguments.length?(u=t,f):u},f.range=s(Gr),f.rangeRound=s(Vr),f.unknown=function(t){return arguments.length?(i=t,f):i},function(i){return r=i,t=i(o),n=i(a),e=t===n?0:1/(n-t),f}}function B_(t,n){return n.domain(t.domain()).interpolator(t.interpolator()).clamp(t.clamp()).unknown(t.unknown())}function Y_(){var t=Lg(O_());return t.copy=function(){return B_(t,Y_()).exponent(t.exponent())},dg.apply(t,arguments)}function L_(){var t,n,e,r,i,o,a,u=0,c=.5,f=1,s=1,l=mg,h=!1;function d(t){return isNaN(t=+t)?a:(t=.5+((t=+o(t))-n)*(s*t<s*n?r:i),l(h?Math.max(0,Math.min(1,t)):t))}function p(t){return function(n){var e,r,i;return arguments.length?([e,r,i]=n,l=di(t,[e,r,i]),d):[l(0),l(.5),l(1)]}}return d.domain=function(a){return arguments.length?([u,c,f]=a,t=o(u=+u),n=o(c=+c),e=o(f=+f),r=t===n?0:.5/(n-t),i=n===e?0:.5/(e-n),s=n<t?-1:1,d):[u,c,f]},d.clamp=function(t){return arguments.length?(h=!!t,d):h},d.interpolator=function(t){return arguments.length?(l=t,d):l},d.range=p(Gr),d.rangeRound=p(Vr),d.unknown=function(t){return arguments.length?(a=t,d):a},function(a){return o=a,t=a(u),n=a(c),e=a(f),r=t===n?0:.5/(n-t),i=n===e?0:.5/(e-n),s=n<t?-1:1,d}}function j_(){var t=Lg(L_());return t.copy=function(){return B_(t,j_()).exponent(t.exponent())},dg.apply(t,arguments)}function H_(t){for(var n=t.length/6|0,e=new Array(n),r=0;r<n;)e[r]="#"+t.slice(6*r,6*++r);return e}var X_=H_("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"),G_=H_("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"),V_=H_("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"),W_=H_("4269d0efb118ff725c6cc5b03ca951ff8ab7a463f297bbf59c6b4e9498a0"),Z_=H_("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"),K_=H_("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"),Q_=H_("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"),J_=H_("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"),tb=H_("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"),nb=H_("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"),eb=H_("4e79a7f28e2ce1575976b7b259a14fedc949af7aa1ff9da79c755fbab0ab"),rb=t=>Fr(t[t.length-1]),ib=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(H_),ob=rb(ib),ab=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(H_),ub=rb(ab),cb=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(H_),fb=rb(cb),sb=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(H_),lb=rb(sb),hb=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(H_),db=rb(hb),pb=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(H_),gb=rb(pb),yb=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(H_),vb=rb(yb),_b=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(H_),bb=rb(_b),mb=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(H_),xb=rb(mb),wb=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(H_),Mb=rb(wb),Tb=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(H_),Ab=rb(Tb),Sb=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(H_),Eb=rb(Sb),Nb=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(H_),kb=rb(Nb),Cb=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(H_),Pb=rb(Cb),zb=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(H_),$b=rb(zb),Db=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(H_),Rb=rb(Db),Fb=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(H_),qb=rb(Fb),Ub=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(H_),Ib=rb(Ub),Ob=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(H_),Bb=rb(Ob),Yb=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(H_),Lb=rb(Yb),jb=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(H_),Hb=rb(jb),Xb=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(H_),Gb=rb(Xb),Vb=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(H_),Wb=rb(Vb),Zb=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(H_),Kb=rb(Zb),Qb=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(H_),Jb=rb(Qb),tm=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(H_),nm=rb(tm),em=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(H_),rm=rb(em);var im=hi(Tr(300,.5,0),Tr(-240,.5,1)),om=hi(Tr(-100,.75,.35),Tr(80,1.5,.8)),am=hi(Tr(260,.75,.35),Tr(80,1.5,.8)),um=Tr();var cm=Fe(),fm=Math.PI/3,sm=2*Math.PI/3;function lm(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}}var hm=lm(H_("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),dm=lm(H_("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),pm=lm(H_("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),gm=lm(H_("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function ym(t){return function(){return t}}const vm=Math.abs,_m=Math.atan2,bm=Math.cos,mm=Math.max,xm=Math.min,wm=Math.sin,Mm=Math.sqrt,Tm=1e-12,Am=Math.PI,Sm=Am/2,Em=2*Am;function Nm(t){return t>=1?Sm:t<=-1?-Sm:Math.asin(t)}function km(t){let n=3;return t.digits=function(e){if(!arguments.length)return n;if(null==e)n=null;else{const t=Math.floor(e);if(!(t>=0))throw new RangeError(`invalid digits: ${e}`);n=t}return t},()=>new Ua(n)}function Cm(t){return t.innerRadius}function Pm(t){return t.outerRadius}function zm(t){return t.startAngle}function $m(t){return t.endAngle}function Dm(t){return t&&t.padAngle}function Rm(t,n,e,r,i,o,a){var u=t-e,c=n-r,f=(a?o:-o)/Mm(u*u+c*c),s=f*c,l=-f*u,h=t+s,d=n+l,p=e+s,g=r+l,y=(h+p)/2,v=(d+g)/2,_=p-h,b=g-d,m=_*_+b*b,x=i-o,w=h*g-p*d,M=(b<0?-1:1)*Mm(mm(0,x*x*m-w*w)),T=(w*b-_*M)/m,A=(-w*_-b*M)/m,S=(w*b+_*M)/m,E=(-w*_+b*M)/m,N=T-y,k=A-v,C=S-y,P=E-v;return N*N+k*k>C*C+P*P&&(T=S,A=E),{cx:T,cy:A,x01:-s,y01:-l,x11:T*(i/x-1),y11:A*(i/x-1)}}var Fm=Array.prototype.slice;function qm(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}function Um(t){this._context=t}function Im(t){return new Um(t)}function Om(t){return t[0]}function Bm(t){return t[1]}function Ym(t,n){var e=ym(!0),r=null,i=Im,o=null,a=km(u);function u(u){var c,f,s,l=(u=qm(u)).length,h=!1;for(null==r&&(o=i(s=a())),c=0;c<=l;++c)!(c<l&&e(f=u[c],c,u))===h&&((h=!h)?o.lineStart():o.lineEnd()),h&&o.point(+t(f,c,u),+n(f,c,u));if(s)return o=null,s+""||null}return t="function"==typeof t?t:void 0===t?Om:ym(t),n="function"==typeof n?n:void 0===n?Bm:ym(n),u.x=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),u):t},u.y=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),u):n},u.defined=function(t){return arguments.length?(e="function"==typeof t?t:ym(!!t),u):e},u.curve=function(t){return arguments.length?(i=t,null!=r&&(o=i(r)),u):i},u.context=function(t){return arguments.length?(null==t?r=o=null:o=i(r=t),u):r},u}function Lm(t,n,e){var r=null,i=ym(!0),o=null,a=Im,u=null,c=km(f);function f(f){var s,l,h,d,p,g=(f=qm(f)).length,y=!1,v=new Array(g),_=new Array(g);for(null==o&&(u=a(p=c())),s=0;s<=g;++s){if(!(s<g&&i(d=f[s],s,f))===y)if(y=!y)l=s,u.areaStart(),u.lineStart();else{for(u.lineEnd(),u.lineStart(),h=s-1;h>=l;--h)u.point(v[h],_[h]);u.lineEnd(),u.areaEnd()}y&&(v[s]=+t(d,s,f),_[s]=+n(d,s,f),u.point(r?+r(d,s,f):v[s],e?+e(d,s,f):_[s]))}if(p)return u=null,p+""||null}function s(){return Ym().defined(i).curve(a).context(o)}return t="function"==typeof t?t:void 0===t?Om:ym(+t),n="function"==typeof n?n:ym(void 0===n?0:+n),e="function"==typeof e?e:void 0===e?Bm:ym(+e),f.x=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),r=null,f):t},f.x0=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),f):t},f.x1=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:ym(+t),f):r},f.y=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),e=null,f):n},f.y0=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),f):n},f.y1=function(t){return arguments.length?(e=null==t?null:"function"==typeof t?t:ym(+t),f):e},f.lineX0=f.lineY0=function(){return s().x(t).y(n)},f.lineY1=function(){return s().x(t).y(e)},f.lineX1=function(){return s().x(r).y(n)},f.defined=function(t){return arguments.length?(i="function"==typeof t?t:ym(!!t),f):i},f.curve=function(t){return arguments.length?(a=t,null!=o&&(u=a(o)),f):a},f.context=function(t){return arguments.length?(null==t?o=u=null:u=a(o=t),f):o},f}function jm(t,n){return n<t?-1:n>t?1:n>=t?0:NaN}function Hm(t){return t}Um.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}};var Xm=Vm(Im);function Gm(t){this._curve=t}function Vm(t){function n(n){return new Gm(t(n))}return n._curve=t,n}function Wm(t){var n=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?n(Vm(t)):n()._curve},t}function Zm(){return Wm(Ym().curve(Xm))}function Km(){var t=Lm().curve(Xm),n=t.curve,e=t.lineX0,r=t.lineX1,i=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return Wm(e())},delete t.lineX0,t.lineEndAngle=function(){return Wm(r())},delete t.lineX1,t.lineInnerRadius=function(){return Wm(i())},delete t.lineY0,t.lineOuterRadius=function(){return Wm(o())},delete t.lineY1,t.curve=function(t){return arguments.length?n(Vm(t)):n()._curve},t}function Qm(t,n){return[(n=+n)*Math.cos(t-=Math.PI/2),n*Math.sin(t)]}Gm.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,n){this._curve.point(n*Math.sin(t),n*-Math.cos(t))}};class Jm{constructor(t,n){this._context=t,this._x=n}areaStart(){this._line=0}areaEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line}point(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._x?this._context.bezierCurveTo(this._x0=(this._x0+t)/2,this._y0,this._x0,n,t,n):this._context.bezierCurveTo(this._x0,this._y0=(this._y0+n)/2,t,this._y0,t,n)}this._x0=t,this._y0=n}}class tx{constructor(t){this._context=t}lineStart(){this._point=0}lineEnd(){}point(t,n){if(t=+t,n=+n,0===this._point)this._point=1;else{const e=Qm(this._x0,this._y0),r=Qm(this._x0,this._y0=(this._y0+n)/2),i=Qm(t,this._y0),o=Qm(t,n);this._context.moveTo(...e),this._context.bezierCurveTo(...r,...i,...o)}this._x0=t,this._y0=n}}function nx(t){return new Jm(t,!0)}function ex(t){return new Jm(t,!1)}function rx(t){return new tx(t)}function ix(t){return t.source}function ox(t){return t.target}function ax(t){let n=ix,e=ox,r=Om,i=Bm,o=null,a=null,u=km(c);function c(){let c;const f=Fm.call(arguments),s=n.apply(this,f),l=e.apply(this,f);if(null==o&&(a=t(c=u())),a.lineStart(),f[0]=s,a.point(+r.apply(this,f),+i.apply(this,f)),f[0]=l,a.point(+r.apply(this,f),+i.apply(this,f)),a.lineEnd(),c)return a=null,c+""||null}return c.source=function(t){return arguments.length?(n=t,c):n},c.target=function(t){return arguments.length?(e=t,c):e},c.x=function(t){return arguments.length?(r="function"==typeof t?t:ym(+t),c):r},c.y=function(t){return arguments.length?(i="function"==typeof t?t:ym(+t),c):i},c.context=function(n){return arguments.length?(null==n?o=a=null:a=t(o=n),c):o},c}const ux=Mm(3);var cx={draw(t,n){const e=.59436*Mm(n+xm(n/28,.75)),r=e/2,i=r*ux;t.moveTo(0,e),t.lineTo(0,-e),t.moveTo(-i,-r),t.lineTo(i,r),t.moveTo(-i,r),t.lineTo(i,-r)}},fx={draw(t,n){const e=Mm(n/Am);t.moveTo(e,0),t.arc(0,0,e,0,Em)}},sx={draw(t,n){const e=Mm(n/5)/2;t.moveTo(-3*e,-e),t.lineTo(-e,-e),t.lineTo(-e,-3*e),t.lineTo(e,-3*e),t.lineTo(e,-e),t.lineTo(3*e,-e),t.lineTo(3*e,e),t.lineTo(e,e),t.lineTo(e,3*e),t.lineTo(-e,3*e),t.lineTo(-e,e),t.lineTo(-3*e,e),t.closePath()}};const lx=Mm(1/3),hx=2*lx;var dx={draw(t,n){const e=Mm(n/hx),r=e*lx;t.moveTo(0,-e),t.lineTo(r,0),t.lineTo(0,e),t.lineTo(-r,0),t.closePath()}},px={draw(t,n){const e=.62625*Mm(n);t.moveTo(0,-e),t.lineTo(e,0),t.lineTo(0,e),t.lineTo(-e,0),t.closePath()}},gx={draw(t,n){const e=.87559*Mm(n-xm(n/7,2));t.moveTo(-e,0),t.lineTo(e,0),t.moveTo(0,e),t.lineTo(0,-e)}},yx={draw(t,n){const e=Mm(n),r=-e/2;t.rect(r,r,e,e)}},vx={draw(t,n){const e=.4431*Mm(n);t.moveTo(e,e),t.lineTo(e,-e),t.lineTo(-e,-e),t.lineTo(-e,e),t.closePath()}};const _x=wm(Am/10)/wm(7*Am/10),bx=wm(Em/10)*_x,mx=-bm(Em/10)*_x;var xx={draw(t,n){const e=Mm(.8908130915292852*n),r=bx*e,i=mx*e;t.moveTo(0,-e),t.lineTo(r,i);for(let n=1;n<5;++n){const o=Em*n/5,a=bm(o),u=wm(o);t.lineTo(u*e,-a*e),t.lineTo(a*r-u*i,u*r+a*i)}t.closePath()}};const wx=Mm(3);var Mx={draw(t,n){const e=-Mm(n/(3*wx));t.moveTo(0,2*e),t.lineTo(-wx*e,-e),t.lineTo(wx*e,-e),t.closePath()}};const Tx=Mm(3);var Ax={draw(t,n){const e=.6824*Mm(n),r=e/2,i=e*Tx/2;t.moveTo(0,-e),t.lineTo(i,r),t.lineTo(-i,r),t.closePath()}};const Sx=-.5,Ex=Mm(3)/2,Nx=1/Mm(12),kx=3*(Nx/2+1);var Cx={draw(t,n){const e=Mm(n/kx),r=e/2,i=e*Nx,o=r,a=e*Nx+e,u=-o,c=a;t.moveTo(r,i),t.lineTo(o,a),t.lineTo(u,c),t.lineTo(Sx*r-Ex*i,Ex*r+Sx*i),t.lineTo(Sx*o-Ex*a,Ex*o+Sx*a),t.lineTo(Sx*u-Ex*c,Ex*u+Sx*c),t.lineTo(Sx*r+Ex*i,Sx*i-Ex*r),t.lineTo(Sx*o+Ex*a,Sx*a-Ex*o),t.lineTo(Sx*u+Ex*c,Sx*c-Ex*u),t.closePath()}},Px={draw(t,n){const e=.6189*Mm(n-xm(n/6,1.7));t.moveTo(-e,-e),t.lineTo(e,e),t.moveTo(-e,e),t.lineTo(e,-e)}};const zx=[fx,sx,dx,yx,xx,Mx,Cx],$x=[fx,gx,Px,Ax,cx,vx,px];function Dx(){}function Rx(t,n,e){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+n)/6,(t._y0+4*t._y1+e)/6)}function Fx(t){this._context=t}function qx(t){this._context=t}function Ux(t){this._context=t}function Ix(t,n){this._basis=new Fx(t),this._beta=n}Fx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Rx(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Rx(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},qx.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x2,this._y2),this._context.closePath();break;case 2:this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break;case 3:this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x2=t,this._y2=n;break;case 1:this._point=2,this._x3=t,this._y3=n;break;case 2:this._point=3,this._x4=t,this._y4=n,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+n)/6);break;default:Rx(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Ux.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var e=(this._x0+4*this._x1+t)/6,r=(this._y0+4*this._y1+n)/6;this._line?this._context.lineTo(e,r):this._context.moveTo(e,r);break;case 3:this._point=4;default:Rx(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Ix.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,n=this._y,e=t.length-1;if(e>0)for(var r,i=t[0],o=n[0],a=t[e]-i,u=n[e]-o,c=-1;++c<=e;)r=c/e,this._basis.point(this._beta*t[c]+(1-this._beta)*(i+r*a),this._beta*n[c]+(1-this._beta)*(o+r*u));this._x=this._y=null,this._basis.lineEnd()},point:function(t,n){this._x.push(+t),this._y.push(+n)}};var Ox=function t(n){function e(t){return 1===n?new Fx(t):new Ix(t,n)}return e.beta=function(n){return t(+n)},e}(.85);function Bx(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function Yx(t,n){this._context=t,this._k=(1-n)/6}Yx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Bx(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:Bx(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Lx=function t(n){function e(t){return new Yx(t,n)}return e.tension=function(n){return t(+n)},e}(0);function jx(t,n){this._context=t,this._k=(1-n)/6}jx.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Bx(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Hx=function t(n){function e(t){return new jx(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Xx(t,n){this._context=t,this._k=(1-n)/6}Xx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Bx(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Gx=function t(n){function e(t){return new Xx(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Vx(t,n,e){var r=t._x1,i=t._y1,o=t._x2,a=t._y2;if(t._l01_a>Tm){var u=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,c=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*u-t._x0*t._l12_2a+t._x2*t._l01_2a)/c,i=(i*u-t._y0*t._l12_2a+t._y2*t._l01_2a)/c}if(t._l23_a>Tm){var f=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,s=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*f+t._x1*t._l23_2a-n*t._l12_2a)/s,a=(a*f+t._y1*t._l23_2a-e*t._l12_2a)/s}t._context.bezierCurveTo(r,i,o,a,t._x2,t._y2)}function Wx(t,n){this._context=t,this._alpha=n}Wx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:Vx(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Zx=function t(n){function e(t){return n?new Wx(t,n):new Yx(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Kx(t,n){this._context=t,this._alpha=n}Kx.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Vx(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Qx=function t(n){function e(t){return n?new Kx(t,n):new jx(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Jx(t,n){this._context=t,this._alpha=n}Jx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Vx(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var tw=function t(n){function e(t){return n?new Jx(t,n):new Xx(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function nw(t){this._context=t}function ew(t){return t<0?-1:1}function rw(t,n,e){var r=t._x1-t._x0,i=n-t._x1,o=(t._y1-t._y0)/(r||i<0&&-0),a=(e-t._y1)/(i||r<0&&-0),u=(o*i+a*r)/(r+i);return(ew(o)+ew(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(u))||0}function iw(t,n){var e=t._x1-t._x0;return e?(3*(t._y1-t._y0)/e-n)/2:n}function ow(t,n,e){var r=t._x0,i=t._y0,o=t._x1,a=t._y1,u=(o-r)/3;t._context.bezierCurveTo(r+u,i+u*n,o-u,a-u*e,o,a)}function aw(t){this._context=t}function uw(t){this._context=new cw(t)}function cw(t){this._context=t}function fw(t){this._context=t}function sw(t){var n,e,r=t.length-1,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=t[0]+2*t[1],n=1;n<r-1;++n)i[n]=1,o[n]=4,a[n]=4*t[n]+2*t[n+1];for(i[r-1]=2,o[r-1]=7,a[r-1]=8*t[r-1]+t[r],n=1;n<r;++n)e=i[n]/o[n-1],o[n]-=e,a[n]-=e*a[n-1];for(i[r-1]=a[r-1]/o[r-1],n=r-2;n>=0;--n)i[n]=(a[n]-i[n+1])/o[n];for(o[r-1]=(t[r]+i[r-1])/2,n=0;n<r-1;++n)o[n]=2*t[n+1]-i[n+1];return[i,o]}function lw(t,n){this._context=t,this._t=n}function hw(t,n){if((i=t.length)>1)for(var e,r,i,o=1,a=t[n[0]],u=a.length;o<i;++o)for(r=a,a=t[n[o]],e=0;e<u;++e)a[e][1]+=a[e][0]=isNaN(r[e][1])?r[e][0]:r[e][1]}function dw(t){for(var n=t.length,e=new Array(n);--n>=0;)e[n]=n;return e}function pw(t,n){return t[n]}function gw(t){const n=[];return n.key=t,n}function yw(t){var n=t.map(vw);return dw(t).sort((function(t,e){return n[t]-n[e]}))}function vw(t){for(var n,e=-1,r=0,i=t.length,o=-1/0;++e<i;)(n=+t[e][1])>o&&(o=n,r=e);return r}function _w(t){var n=t.map(bw);return dw(t).sort((function(t,e){return n[t]-n[e]}))}function bw(t){for(var n,e=0,r=-1,i=t.length;++r<i;)(n=+t[r][1])&&(e+=n);return e}nw.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._point=0},lineEnd:function(){this._point&&this._context.closePath()},point:function(t,n){t=+t,n=+n,this._point?this._context.lineTo(t,n):(this._point=1,this._context.moveTo(t,n))}},aw.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=this._t0=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x1,this._y1);break;case 3:ow(this,this._t0,iw(this,this._t0))}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){var e=NaN;if(n=+n,(t=+t)!==this._x1||n!==this._y1){switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,ow(this,iw(this,e=rw(this,t,n)),e);break;default:ow(this,this._t0,e=rw(this,t,n))}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n,this._t0=e}}},(uw.prototype=Object.create(aw.prototype)).point=function(t,n){aw.prototype.point.call(this,n,t)},cw.prototype={moveTo:function(t,n){this._context.moveTo(n,t)},closePath:function(){this._context.closePath()},lineTo:function(t,n){this._context.lineTo(n,t)},bezierCurveTo:function(t,n,e,r,i,o){this._context.bezierCurveTo(n,t,r,e,o,i)}},fw.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=[],this._y=[]},lineEnd:function(){var t=this._x,n=this._y,e=t.length;if(e)if(this._line?this._context.lineTo(t[0],n[0]):this._context.moveTo(t[0],n[0]),2===e)this._context.lineTo(t[1],n[1]);else for(var r=sw(t),i=sw(n),o=0,a=1;a<e;++o,++a)this._context.bezierCurveTo(r[0][o],i[0][o],r[1][o],i[1][o],t[a],n[a]);(this._line||0!==this._line&&1===e)&&this._context.closePath(),this._line=1-this._line,this._x=this._y=null},point:function(t,n){this._x.push(+t),this._y.push(+n)}},lw.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x=this._y=NaN,this._point=0},lineEnd:function(){0<this._t&&this._t<1&&2===this._point&&this._context.lineTo(this._x,this._y),(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line>=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,n),this._context.lineTo(t,n);else{var e=this._x*(1-this._t)+t*this._t;this._context.lineTo(e,this._y),this._context.lineTo(e,n)}}this._x=t,this._y=n}};var mw=t=>()=>t;function xw(t,{sourceEvent:n,target:e,transform:r,dispatch:i}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},target:{value:e,enumerable:!0,configurable:!0},transform:{value:r,enumerable:!0,configurable:!0},_:{value:i}})}function ww(t,n,e){this.k=t,this.x=n,this.y=e}ww.prototype={constructor:ww,scale:function(t){return 1===t?this:new ww(this.k*t,this.x,this.y)},translate:function(t,n){return 0===t&0===n?this:new ww(this.k,this.x+this.k*t,this.y+this.k*n)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Mw=new ww(1,0,0);function Tw(t){for(;!t.__zoom;)if(!(t=t.parentNode))return Mw;return t.__zoom}function Aw(t){t.stopImmediatePropagation()}function Sw(t){t.preventDefault(),t.stopImmediatePropagation()}function Ew(t){return!(t.ctrlKey&&"wheel"!==t.type||t.button)}function Nw(){var t=this;return t instanceof SVGElement?(t=t.ownerSVGElement||t).hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]:[[0,0],[t.clientWidth,t.clientHeight]]}function kw(){return this.__zoom||Mw}function Cw(t){return-t.deltaY*(1===t.deltaMode?.05:t.deltaMode?1:.002)*(t.ctrlKey?10:1)}function Pw(){return navigator.maxTouchPoints||"ontouchstart"in this}function zw(t,n,e){var r=t.invertX(n[0][0])-e[0][0],i=t.invertX(n[1][0])-e[1][0],o=t.invertY(n[0][1])-e[0][1],a=t.invertY(n[1][1])-e[1][1];return t.translate(i>r?(r+i)/2:Math.min(0,r)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}Tw.prototype=ww.prototype,t.Adder=T,t.Delaunay=Lu,t.FormatSpecifier=tf,t.InternMap=InternMap,t.InternSet=InternSet,t.Node=Qd,t.Path=Ua,t.Voronoi=qu,t.ZoomTransform=ww,t.active=function(t,n){var e,r,i=t.__transition;if(i)for(r in n=null==n?null:n+"",i)if((e=i[r]).state>qi&&e.name===n)return new po([[t]],Zo,n,+r);return null},t.arc=function(){var t=Cm,n=Pm,e=ym(0),r=null,i=zm,o=$m,a=Dm,u=null,c=km(f);function f(){var f,s,l=+t.apply(this,arguments),h=+n.apply(this,arguments),d=i.apply(this,arguments)-Sm,p=o.apply(this,arguments)-Sm,g=vm(p-d),y=p>d;if(u||(u=f=c()),h<l&&(s=h,h=l,l=s),h>Tm)if(g>Em-Tm)u.moveTo(h*bm(d),h*wm(d)),u.arc(0,0,h,d,p,!y),l>Tm&&(u.moveTo(l*bm(p),l*wm(p)),u.arc(0,0,l,p,d,y));else{var v,_,b=d,m=p,x=d,w=p,M=g,T=g,A=a.apply(this,arguments)/2,S=A>Tm&&(r?+r.apply(this,arguments):Mm(l*l+h*h)),E=xm(vm(h-l)/2,+e.apply(this,arguments)),N=E,k=E;if(S>Tm){var C=Nm(S/l*wm(A)),P=Nm(S/h*wm(A));(M-=2*C)>Tm?(x+=C*=y?1:-1,w-=C):(M=0,x=w=(d+p)/2),(T-=2*P)>Tm?(b+=P*=y?1:-1,m-=P):(T=0,b=m=(d+p)/2)}var z=h*bm(b),$=h*wm(b),D=l*bm(w),R=l*wm(w);if(E>Tm){var F,q=h*bm(m),U=h*wm(m),I=l*bm(x),O=l*wm(x);if(g<Am)if(F=function(t,n,e,r,i,o,a,u){var c=e-t,f=r-n,s=a-i,l=u-o,h=l*c-s*f;if(!(h*h<Tm))return[t+(h=(s*(n-o)-l*(t-i))/h)*c,n+h*f]}(z,$,I,O,q,U,D,R)){var B=z-F[0],Y=$-F[1],L=q-F[0],j=U-F[1],H=1/wm(function(t){return t>1?0:t<-1?Am:Math.acos(t)}((B*L+Y*j)/(Mm(B*B+Y*Y)*Mm(L*L+j*j)))/2),X=Mm(F[0]*F[0]+F[1]*F[1]);N=xm(E,(l-X)/(H-1)),k=xm(E,(h-X)/(H+1))}else N=k=0}T>Tm?k>Tm?(v=Rm(I,O,z,$,h,k,y),_=Rm(q,U,D,R,h,k,y),u.moveTo(v.cx+v.x01,v.cy+v.y01),k<E?u.arc(v.cx,v.cy,k,_m(v.y01,v.x01),_m(_.y01,_.x01),!y):(u.arc(v.cx,v.cy,k,_m(v.y01,v.x01),_m(v.y11,v.x11),!y),u.arc(0,0,h,_m(v.cy+v.y11,v.cx+v.x11),_m(_.cy+_.y11,_.cx+_.x11),!y),u.arc(_.cx,_.cy,k,_m(_.y11,_.x11),_m(_.y01,_.x01),!y))):(u.moveTo(z,$),u.arc(0,0,h,b,m,!y)):u.moveTo(z,$),l>Tm&&M>Tm?N>Tm?(v=Rm(D,R,q,U,l,-N,y),_=Rm(z,$,I,O,l,-N,y),u.lineTo(v.cx+v.x01,v.cy+v.y01),N<E?u.arc(v.cx,v.cy,N,_m(v.y01,v.x01),_m(_.y01,_.x01),!y):(u.arc(v.cx,v.cy,N,_m(v.y01,v.x01),_m(v.y11,v.x11),!y),u.arc(0,0,l,_m(v.cy+v.y11,v.cx+v.x11),_m(_.cy+_.y11,_.cx+_.x11),y),u.arc(_.cx,_.cy,N,_m(_.y11,_.x11),_m(_.y01,_.x01),!y))):u.arc(0,0,l,w,x,y):u.lineTo(D,R)}else u.moveTo(0,0);if(u.closePath(),f)return u=null,f+""||null}return f.centroid=function(){var e=(+t.apply(this,arguments)+ +n.apply(this,arguments))/2,r=(+i.apply(this,arguments)+ +o.apply(this,arguments))/2-Am/2;return[bm(r)*e,wm(r)*e]},f.innerRadius=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),f):t},f.outerRadius=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),f):n},f.cornerRadius=function(t){return arguments.length?(e="function"==typeof t?t:ym(+t),f):e},f.padRadius=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:ym(+t),f):r},f.startAngle=function(t){return arguments.length?(i="function"==typeof t?t:ym(+t),f):i},f.endAngle=function(t){return arguments.length?(o="function"==typeof t?t:ym(+t),f):o},f.padAngle=function(t){return arguments.length?(a="function"==typeof t?t:ym(+t),f):a},f.context=function(t){return arguments.length?(u=null==t?null:t,f):u},f},t.area=Lm,t.areaRadial=Km,t.ascending=n,t.autoType=function(t){for(var n in t){var e,r,i=t[n].trim();if(i)if("true"===i)i=!0;else if("false"===i)i=!1;else if("NaN"===i)i=NaN;else if(isNaN(e=+i)){if(!(r=i.match(/^([-+]\d{2})?\d{4}(-\d{2}(-\d{2})?)?(T\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/)))continue;yc&&r[4]&&!r[7]&&(i=i.replace(/-/g,"/").replace(/T/," ")),i=new Date(i)}else i=e;else i=null;t[n]=i}return t},t.axisBottom=function(t){return Pt(Mt,t)},t.axisLeft=function(t){return Pt(Tt,t)},t.axisRight=function(t){return Pt(wt,t)},t.axisTop=function(t){return Pt(xt,t)},t.bin=Q,t.bisect=s,t.bisectCenter=f,t.bisectLeft=c,t.bisectRight=u,t.bisector=r,t.blob=function(t,n){return fetch(t,n).then(vc)},t.blur=function(t,n){if(!((n=+n)>=0))throw new RangeError("invalid r");let e=t.length;if(!((e=Math.floor(e))>=0))throw new RangeError("invalid length");if(!e||!n)return t;const r=y(n),i=t.slice();return r(t,i,0,e,1),r(i,t,0,e,1),r(t,i,0,e,1),t},t.blur2=l,t.blurImage=h,t.brush=function(){return wa(la)},t.brushSelection=function(t){var n=t.__brush;return n?n.dim.output(n.selection):null},t.brushX=function(){return wa(fa)},t.brushY=function(){return wa(sa)},t.buffer=function(t,n){return fetch(t,n).then(_c)},t.chord=function(){return za(!1,!1)},t.chordDirected=function(){return za(!0,!1)},t.chordTranspose=function(){return za(!1,!0)},t.cluster=function(){var t=Ld,n=1,e=1,r=!1;function i(i){var o,a=0;i.eachAfter((function(n){var e=n.children;e?(n.x=function(t){return t.reduce(jd,0)/t.length}(e),n.y=function(t){return 1+t.reduce(Hd,0)}(e)):(n.x=o?a+=t(n,o):0,n.y=0,o=n)}));var u=function(t){for(var n;n=t.children;)t=n[0];return t}(i),c=function(t){for(var n;n=t.children;)t=n[n.length-1];return t}(i),f=u.x-t(u,c)/2,s=c.x+t(c,u)/2;return i.eachAfter(r?function(t){t.x=(t.x-i.x)*n,t.y=(i.y-t.y)*e}:function(t){t.x=(t.x-f)/(s-f)*n,t.y=(1-(i.y?t.y/i.y:1))*e})}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.color=ze,t.contourDensity=function(){var t=fu,n=su,e=lu,r=960,i=500,o=20,a=2,u=3*o,c=r+2*u>>a,f=i+2*u>>a,s=Qa(20);function h(r){var i=new Float32Array(c*f),s=Math.pow(2,-a),h=-1;for(const o of r){var d=(t(o,++h,r)+u)*s,p=(n(o,h,r)+u)*s,g=+e(o,h,r);if(g&&d>=0&&d<c&&p>=0&&p<f){var y=Math.floor(d),v=Math.floor(p),_=d-y-.5,b=p-v-.5;i[y+v*c]+=(1-_)*(1-b)*g,i[y+1+v*c]+=_*(1-b)*g,i[y+1+(v+1)*c]+=_*b*g,i[y+(v+1)*c]+=(1-_)*b*g}}return l({data:i,width:c,height:f},o*s),i}function d(t){var n=h(t),e=s(n),r=Math.pow(2,2*a);return Array.isArray(e)||(e=G(Number.MIN_VALUE,J(n)/r,e)),iu().size([c,f]).thresholds(e.map((t=>t*r)))(n).map(((t,n)=>(t.value=+e[n],p(t))))}function p(t){return t.coordinates.forEach(g),t}function g(t){t.forEach(y)}function y(t){t.forEach(v)}function v(t){t[0]=t[0]*Math.pow(2,a)-u,t[1]=t[1]*Math.pow(2,a)-u}function _(){return c=r+2*(u=3*o)>>a,f=i+2*u>>a,d}return d.contours=function(t){var n=h(t),e=iu().size([c,f]),r=Math.pow(2,2*a),i=t=>{t=+t;var i=p(e.contour(n,t*r));return i.value=t,i};return Object.defineProperty(i,"max",{get:()=>J(n)/r}),i},d.x=function(n){return arguments.length?(t="function"==typeof n?n:Qa(+n),d):t},d.y=function(t){return arguments.length?(n="function"==typeof t?t:Qa(+t),d):n},d.weight=function(t){return arguments.length?(e="function"==typeof t?t:Qa(+t),d):e},d.size=function(t){if(!arguments.length)return[r,i];var n=+t[0],e=+t[1];if(!(n>=0&&e>=0))throw new Error("invalid size");return r=n,i=e,_()},d.cellSize=function(t){if(!arguments.length)return 1<<a;if(!((t=+t)>=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(t)/Math.LN2),_()},d.thresholds=function(t){return arguments.length?(s="function"==typeof t?t:Array.isArray(t)?Qa(Za.call(t)):Qa(t),d):s},d.bandwidth=function(t){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((t=+t)>=0))throw new Error("invalid bandwidth");return o=(Math.sqrt(4*t*t+1)-1)/2,_()},d},t.contours=iu,t.count=v,t.create=function(t){return Zn(Yt(t).call(document.documentElement))},t.creator=Yt,t.cross=function(...t){const n="function"==typeof t[t.length-1]&&function(t){return n=>t(...n)}(t.pop()),e=(t=t.map(m)).map(_),r=t.length-1,i=new Array(r+1).fill(0),o=[];if(r<0||e.some(b))return o;for(;;){o.push(i.map(((n,e)=>t[e][n])));let a=r;for(;++i[a]===e[a];){if(0===a)return n?o.map(n):o;i[a--]=0}}},t.csv=wc,t.csvFormat=rc,t.csvFormatBody=ic,t.csvFormatRow=ac,t.csvFormatRows=oc,t.csvFormatValue=uc,t.csvParse=nc,t.csvParseRows=ec,t.cubehelix=Tr,t.cumsum=function(t,n){var e=0,r=0;return Float64Array.from(t,void 0===n?t=>e+=+t||0:i=>e+=+n(i,r++,t)||0)},t.curveBasis=function(t){return new Fx(t)},t.curveBasisClosed=function(t){return new qx(t)},t.curveBasisOpen=function(t){return new Ux(t)},t.curveBumpX=nx,t.curveBumpY=ex,t.curveBundle=Ox,t.curveCardinal=Lx,t.curveCardinalClosed=Hx,t.curveCardinalOpen=Gx,t.curveCatmullRom=Zx,t.curveCatmullRomClosed=Qx,t.curveCatmullRomOpen=tw,t.curveLinear=Im,t.curveLinearClosed=function(t){return new nw(t)},t.curveMonotoneX=function(t){return new aw(t)},t.curveMonotoneY=function(t){return new uw(t)},t.curveNatural=function(t){return new fw(t)},t.curveStep=function(t){return new lw(t,.5)},t.curveStepAfter=function(t){return new lw(t,1)},t.curveStepBefore=function(t){return new lw(t,0)},t.descending=e,t.deviation=w,t.difference=function(t,...n){t=new InternSet(t);for(const e of n)for(const n of e)t.delete(n);return t},t.disjoint=function(t,n){const e=n[Symbol.iterator](),r=new InternSet;for(const n of t){if(r.has(n))return!1;let t,i;for(;({value:t,done:i}=e.next())&&!i;){if(Object.is(n,t))return!1;r.add(t)}}return!0},t.dispatch=$t,t.drag=function(){var t,n,e,r,i=se,o=le,a=he,u=de,c={},f=$t("start","drag","end"),s=0,l=0;function h(t){t.on("mousedown.drag",d).filter(u).on("touchstart.drag",y).on("touchmove.drag",v,ee).on("touchend.drag touchcancel.drag",_).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function d(a,u){if(!r&&i.call(this,a,u)){var c=b(this,o.call(this,a,u),a,u,"mouse");c&&(Zn(a.view).on("mousemove.drag",p,re).on("mouseup.drag",g,re),ae(a.view),ie(a),e=!1,t=a.clientX,n=a.clientY,c("start",a))}}function p(r){if(oe(r),!e){var i=r.clientX-t,o=r.clientY-n;e=i*i+o*o>l}c.mouse("drag",r)}function g(t){Zn(t.view).on("mousemove.drag mouseup.drag",null),ue(t.view,e),oe(t),c.mouse("end",t)}function y(t,n){if(i.call(this,t,n)){var e,r,a=t.changedTouches,u=o.call(this,t,n),c=a.length;for(e=0;e<c;++e)(r=b(this,u,t,n,a[e].identifier,a[e]))&&(ie(t),r("start",t,a[e]))}}function v(t){var n,e,r=t.changedTouches,i=r.length;for(n=0;n<i;++n)(e=c[r[n].identifier])&&(oe(t),e("drag",t,r[n]))}function _(t){var n,e,i=t.changedTouches,o=i.length;for(r&&clearTimeout(r),r=setTimeout((function(){r=null}),500),n=0;n<o;++n)(e=c[i[n].identifier])&&(ie(t),e("end",t,i[n]))}function b(t,n,e,r,i,o){var u,l,d,p=f.copy(),g=ne(o||e,n);if(null!=(d=a.call(t,new fe("beforestart",{sourceEvent:e,target:h,identifier:i,active:s,x:g[0],y:g[1],dx:0,dy:0,dispatch:p}),r)))return u=d.x-g[0]||0,l=d.y-g[1]||0,function e(o,a,f){var y,v=g;switch(o){case"start":c[i]=e,y=s++;break;case"end":delete c[i],--s;case"drag":g=ne(f||a,n),y=s}p.call(o,t,new fe(o,{sourceEvent:a,subject:d,target:h,identifier:i,active:y,x:g[0]+u,y:g[1]+l,dx:g[0]-v[0],dy:g[1]-v[1],dispatch:p}),r)}}return h.filter=function(t){return arguments.length?(i="function"==typeof t?t:ce(!!t),h):i},h.container=function(t){return arguments.length?(o="function"==typeof t?t:ce(t),h):o},h.subject=function(t){return arguments.length?(a="function"==typeof t?t:ce(t),h):a},h.touchable=function(t){return arguments.length?(u="function"==typeof t?t:ce(!!t),h):u},h.on=function(){var t=f.on.apply(f,arguments);return t===f?h:t},h.clickDistance=function(t){return arguments.length?(l=(t=+t)*t,h):Math.sqrt(l)},h},t.dragDisable=ae,t.dragEnable=ue,t.dsv=function(t,n,e,r){3===arguments.length&&"function"==typeof e&&(r=e,e=void 0);var i=Ju(t);return mc(n,e).then((function(t){return i.parse(t,r)}))},t.dsvFormat=Ju,t.easeBack=Lo,t.easeBackIn=Bo,t.easeBackInOut=Lo,t.easeBackOut=Yo,t.easeBounce=Io,t.easeBounceIn=function(t){return 1-Io(1-t)},t.easeBounceInOut=function(t){return((t*=2)<=1?1-Io(1-t):Io(t-1)+1)/2},t.easeBounceOut=Io,t.easeCircle=No,t.easeCircleIn=function(t){return 1-Math.sqrt(1-t*t)},t.easeCircleInOut=No,t.easeCircleOut=function(t){return Math.sqrt(1- --t*t)},t.easeCubic=bo,t.easeCubicIn=function(t){return t*t*t},t.easeCubicInOut=bo,t.easeCubicOut=function(t){return--t*t*t+1},t.easeElastic=Xo,t.easeElasticIn=Ho,t.easeElasticInOut=Go,t.easeElasticOut=Xo,t.easeExp=Eo,t.easeExpIn=function(t){return So(1-+t)},t.easeExpInOut=Eo,t.easeExpOut=function(t){return 1-So(t)},t.easeLinear=t=>+t,t.easePoly=wo,t.easePolyIn=mo,t.easePolyInOut=wo,t.easePolyOut=xo,t.easeQuad=_o,t.easeQuadIn=function(t){return t*t},t.easeQuadInOut=_o,t.easeQuadOut=function(t){return t*(2-t)},t.easeSin=Ao,t.easeSinIn=function(t){return 1==+t?1:1-Math.cos(t*To)},t.easeSinInOut=Ao,t.easeSinOut=function(t){return Math.sin(t*To)},t.every=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");let e=-1;for(const r of t)if(!n(r,++e,t))return!1;return!0},t.extent=M,t.fcumsum=function(t,n){const e=new T;let r=-1;return Float64Array.from(t,void 0===n?t=>e.add(+t||0):i=>e.add(+n(i,++r,t)||0))},t.filter=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");const e=[];let r=-1;for(const i of t)n(i,++r,t)&&e.push(i);return e},t.flatGroup=function(t,...n){return z(P(t,...n),n)},t.flatRollup=function(t,n,...e){return z(D(t,n,...e),e)},t.forceCenter=function(t,n){var e,r=1;function i(){var i,o,a=e.length,u=0,c=0;for(i=0;i<a;++i)u+=(o=e[i]).x,c+=o.y;for(u=(u/a-t)*r,c=(c/a-n)*r,i=0;i<a;++i)(o=e[i]).x-=u,o.y-=c}return null==t&&(t=0),null==n&&(n=0),i.initialize=function(t){e=t},i.x=function(n){return arguments.length?(t=+n,i):t},i.y=function(t){return arguments.length?(n=+t,i):n},i.strength=function(t){return arguments.length?(r=+t,i):r},i},t.forceCollide=function(t){var n,e,r,i=1,o=1;function a(){for(var t,a,c,f,s,l,h,d=n.length,p=0;p<o;++p)for(a=$c(n,Ic,Oc).visitAfter(u),t=0;t<d;++t)c=n[t],l=e[c.index],h=l*l,f=c.x+c.vx,s=c.y+c.vy,a.visit(g);function g(t,n,e,o,a){var u=t.data,d=t.r,p=l+d;if(!u)return n>f+p||o<f-p||e>s+p||a<s-p;if(u.index>c.index){var g=f-u.x-u.vx,y=s-u.y-u.vy,v=g*g+y*y;v<p*p&&(0===g&&(v+=(g=Uc(r))*g),0===y&&(v+=(y=Uc(r))*y),v=(p-(v=Math.sqrt(v)))/v*i,c.vx+=(g*=v)*(p=(d*=d)/(h+d)),c.vy+=(y*=v)*p,u.vx-=g*(p=1-p),u.vy-=y*p)}}}function u(t){if(t.data)return t.r=e[t.data.index];for(var n=t.r=0;n<4;++n)t[n]&&t[n].r>t.r&&(t.r=t[n].r)}function c(){if(n){var r,i,o=n.length;for(e=new Array(o),r=0;r<o;++r)i=n[r],e[i.index]=+t(i,r,n)}}return"function"!=typeof t&&(t=qc(null==t?1:+t)),a.initialize=function(t,e){n=t,r=e,c()},a.iterations=function(t){return arguments.length?(o=+t,a):o},a.strength=function(t){return arguments.length?(i=+t,a):i},a.radius=function(n){return arguments.length?(t="function"==typeof n?n:qc(+n),c(),a):t},a},t.forceLink=function(t){var n,e,r,i,o,a,u=Bc,c=function(t){return 1/Math.min(i[t.source.index],i[t.target.index])},f=qc(30),s=1;function l(r){for(var i=0,u=t.length;i<s;++i)for(var c,f,l,h,d,p,g,y=0;y<u;++y)f=(c=t[y]).source,h=(l=c.target).x+l.vx-f.x-f.vx||Uc(a),d=l.y+l.vy-f.y-f.vy||Uc(a),h*=p=((p=Math.sqrt(h*h+d*d))-e[y])/p*r*n[y],d*=p,l.vx-=h*(g=o[y]),l.vy-=d*g,f.vx+=h*(g=1-g),f.vy+=d*g}function h(){if(r){var a,c,f=r.length,s=t.length,l=new Map(r.map(((t,n)=>[u(t,n,r),t])));for(a=0,i=new Array(f);a<s;++a)(c=t[a]).index=a,"object"!=typeof c.source&&(c.source=Yc(l,c.source)),"object"!=typeof c.target&&(c.target=Yc(l,c.target)),i[c.source.index]=(i[c.source.index]||0)+1,i[c.target.index]=(i[c.target.index]||0)+1;for(a=0,o=new Array(s);a<s;++a)c=t[a],o[a]=i[c.source.index]/(i[c.source.index]+i[c.target.index]);n=new Array(s),d(),e=new Array(s),p()}}function d(){if(r)for(var e=0,i=t.length;e<i;++e)n[e]=+c(t[e],e,t)}function p(){if(r)for(var n=0,i=t.length;n<i;++n)e[n]=+f(t[n],n,t)}return null==t&&(t=[]),l.initialize=function(t,n){r=t,a=n,h()},l.links=function(n){return arguments.length?(t=n,h(),l):t},l.id=function(t){return arguments.length?(u=t,l):u},l.iterations=function(t){return arguments.length?(s=+t,l):s},l.strength=function(t){return arguments.length?(c="function"==typeof t?t:qc(+t),d(),l):c},l.distance=function(t){return arguments.length?(f="function"==typeof t?t:qc(+t),p(),l):f},l},t.forceManyBody=function(){var t,n,e,r,i,o=qc(-30),a=1,u=1/0,c=.81;function f(e){var i,o=t.length,a=$c(t,Xc,Gc).visitAfter(l);for(r=e,i=0;i<o;++i)n=t[i],a.visit(h)}function s(){if(t){var n,e,r=t.length;for(i=new Array(r),n=0;n<r;++n)e=t[n],i[e.index]=+o(e,n,t)}}function l(t){var n,e,r,o,a,u=0,c=0;if(t.length){for(r=o=a=0;a<4;++a)(n=t[a])&&(e=Math.abs(n.value))&&(u+=n.value,c+=e,r+=e*n.x,o+=e*n.y);t.x=r/c,t.y=o/c}else{(n=t).x=n.data.x,n.y=n.data.y;do{u+=i[n.data.index]}while(n=n.next)}t.value=u}function h(t,o,f,s){if(!t.value)return!0;var l=t.x-n.x,h=t.y-n.y,d=s-o,p=l*l+h*h;if(d*d/c<p)return p<u&&(0===l&&(p+=(l=Uc(e))*l),0===h&&(p+=(h=Uc(e))*h),p<a&&(p=Math.sqrt(a*p)),n.vx+=l*t.value*r/p,n.vy+=h*t.value*r/p),!0;if(!(t.length||p>=u)){(t.data!==n||t.next)&&(0===l&&(p+=(l=Uc(e))*l),0===h&&(p+=(h=Uc(e))*h),p<a&&(p=Math.sqrt(a*p)));do{t.data!==n&&(d=i[t.data.index]*r/p,n.vx+=l*d,n.vy+=h*d)}while(t=t.next)}}return f.initialize=function(n,r){t=n,e=r,s()},f.strength=function(t){return arguments.length?(o="function"==typeof t?t:qc(+t),s(),f):o},f.distanceMin=function(t){return arguments.length?(a=t*t,f):Math.sqrt(a)},f.distanceMax=function(t){return arguments.length?(u=t*t,f):Math.sqrt(u)},f.theta=function(t){return arguments.length?(c=t*t,f):Math.sqrt(c)},f},t.forceRadial=function(t,n,e){var r,i,o,a=qc(.1);function u(t){for(var a=0,u=r.length;a<u;++a){var c=r[a],f=c.x-n||1e-6,s=c.y-e||1e-6,l=Math.sqrt(f*f+s*s),h=(o[a]-l)*i[a]*t/l;c.vx+=f*h,c.vy+=s*h}}function c(){if(r){var n,e=r.length;for(i=new Array(e),o=new Array(e),n=0;n<e;++n)o[n]=+t(r[n],n,r),i[n]=isNaN(o[n])?0:+a(r[n],n,r)}}return"function"!=typeof t&&(t=qc(+t)),null==n&&(n=0),null==e&&(e=0),u.initialize=function(t){r=t,c()},u.strength=function(t){return arguments.length?(a="function"==typeof t?t:qc(+t),c(),u):a},u.radius=function(n){return arguments.length?(t="function"==typeof n?n:qc(+n),c(),u):t},u.x=function(t){return arguments.length?(n=+t,u):n},u.y=function(t){return arguments.length?(e=+t,u):e},u},t.forceSimulation=function(t){var n,e=1,r=.001,i=1-Math.pow(r,1/300),o=0,a=.6,u=new Map,c=Ni(l),f=$t("tick","end"),s=function(){let t=1;return()=>(t=(Lc*t+jc)%Hc)/Hc}();function l(){h(),f.call("tick",n),e<r&&(c.stop(),f.call("end",n))}function h(r){var c,f,s=t.length;void 0===r&&(r=1);for(var l=0;l<r;++l)for(e+=(o-e)*i,u.forEach((function(t){t(e)})),c=0;c<s;++c)null==(f=t[c]).fx?f.x+=f.vx*=a:(f.x=f.fx,f.vx=0),null==f.fy?f.y+=f.vy*=a:(f.y=f.fy,f.vy=0);return n}function d(){for(var n,e=0,r=t.length;e<r;++e){if((n=t[e]).index=e,null!=n.fx&&(n.x=n.fx),null!=n.fy&&(n.y=n.fy),isNaN(n.x)||isNaN(n.y)){var i=10*Math.sqrt(.5+e),o=e*Vc;n.x=i*Math.cos(o),n.y=i*Math.sin(o)}(isNaN(n.vx)||isNaN(n.vy))&&(n.vx=n.vy=0)}}function p(n){return n.initialize&&n.initialize(t,s),n}return null==t&&(t=[]),d(),n={tick:h,restart:function(){return c.restart(l),n},stop:function(){return c.stop(),n},nodes:function(e){return arguments.length?(t=e,d(),u.forEach(p),n):t},alpha:function(t){return arguments.length?(e=+t,n):e},alphaMin:function(t){return arguments.length?(r=+t,n):r},alphaDecay:function(t){return arguments.length?(i=+t,n):+i},alphaTarget:function(t){return arguments.length?(o=+t,n):o},velocityDecay:function(t){return arguments.length?(a=1-t,n):1-a},randomSource:function(t){return arguments.length?(s=t,u.forEach(p),n):s},force:function(t,e){return arguments.length>1?(null==e?u.delete(t):u.set(t,p(e)),n):u.get(t)},find:function(n,e,r){var i,o,a,u,c,f=0,s=t.length;for(null==r?r=1/0:r*=r,f=0;f<s;++f)(a=(i=n-(u=t[f]).x)*i+(o=e-u.y)*o)<r&&(c=u,r=a);return c},on:function(t,e){return arguments.length>1?(f.on(t,e),n):f.on(t)}}},t.forceX=function(t){var n,e,r,i=qc(.1);function o(t){for(var i,o=0,a=n.length;o<a;++o)(i=n[o]).vx+=(r[o]-i.x)*e[o]*t}function a(){if(n){var o,a=n.length;for(e=new Array(a),r=new Array(a),o=0;o<a;++o)e[o]=isNaN(r[o]=+t(n[o],o,n))?0:+i(n[o],o,n)}}return"function"!=typeof t&&(t=qc(null==t?0:+t)),o.initialize=function(t){n=t,a()},o.strength=function(t){return arguments.length?(i="function"==typeof t?t:qc(+t),a(),o):i},o.x=function(n){return arguments.length?(t="function"==typeof n?n:qc(+n),a(),o):t},o},t.forceY=function(t){var n,e,r,i=qc(.1);function o(t){for(var i,o=0,a=n.length;o<a;++o)(i=n[o]).vy+=(r[o]-i.y)*e[o]*t}function a(){if(n){var o,a=n.length;for(e=new Array(a),r=new Array(a),o=0;o<a;++o)e[o]=isNaN(r[o]=+t(n[o],o,n))?0:+i(n[o],o,n)}}return"function"!=typeof t&&(t=qc(null==t?0:+t)),o.initialize=function(t){n=t,a()},o.strength=function(t){return arguments.length?(i="function"==typeof t?t:qc(+t),a(),o):i},o.y=function(n){return arguments.length?(t="function"==typeof n?n:qc(+n),a(),o):t},o},t.formatDefaultLocale=ff,t.formatLocale=cf,t.formatSpecifier=Jc,t.fsum=function(t,n){const e=new T;if(void 0===n)for(let n of t)(n=+n)&&e.add(n);else{let r=-1;for(let i of t)(i=+n(i,++r,t))&&e.add(i)}return+e},t.geoAlbers=xd,t.geoAlbersUsa=function(){var t,n,e,r,i,o,a=xd(),u=md().rotate([154,0]).center([-2,58.5]).parallels([55,65]),c=md().rotate([157,0]).center([-3,19.9]).parallels([8,18]),f={point:function(t,n){o=[t,n]}};function s(t){var n=t[0],a=t[1];return o=null,e.point(n,a),o||(r.point(n,a),o)||(i.point(n,a),o)}function l(){return t=n=null,s}return s.invert=function(t){var n=a.scale(),e=a.translate(),r=(t[0]-e[0])/n,i=(t[1]-e[1])/n;return(i>=.12&&i<.234&&r>=-.425&&r<-.214?u:i>=.166&&i<.234&&r>=-.214&&r<-.115?c:a).invert(t)},s.stream=function(e){return t&&n===e?t:(r=[a.stream(n=e),u.stream(e),c.stream(e)],i=r.length,t={point:function(t,n){for(var e=-1;++e<i;)r[e].point(t,n)},sphere:function(){for(var t=-1;++t<i;)r[t].sphere()},lineStart:function(){for(var t=-1;++t<i;)r[t].lineStart()},lineEnd:function(){for(var t=-1;++t<i;)r[t].lineEnd()},polygonStart:function(){for(var t=-1;++t<i;)r[t].polygonStart()},polygonEnd:function(){for(var t=-1;++t<i;)r[t].polygonEnd()}});var r,i},s.precision=function(t){return arguments.length?(a.precision(t),u.precision(t),c.precision(t),l()):a.precision()},s.scale=function(t){return arguments.length?(a.scale(t),u.scale(.35*t),c.scale(t),s.translate(a.translate())):a.scale()},s.translate=function(t){if(!arguments.length)return a.translate();var n=a.scale(),o=+t[0],s=+t[1];return e=a.translate(t).clipExtent([[o-.455*n,s-.238*n],[o+.455*n,s+.238*n]]).stream(f),r=u.translate([o-.307*n,s+.201*n]).clipExtent([[o-.425*n+df,s+.12*n+df],[o-.214*n-df,s+.234*n-df]]).stream(f),i=c.translate([o-.205*n,s+.212*n]).clipExtent([[o-.214*n+df,s+.166*n+df],[o-.115*n-df,s+.234*n-df]]).stream(f),l()},s.fitExtent=function(t,n){return ud(s,t,n)},s.fitSize=function(t,n){return cd(s,t,n)},s.fitWidth=function(t,n){return fd(s,t,n)},s.fitHeight=function(t,n){return sd(s,t,n)},s.scale(1070)},t.geoArea=function(t){return us=new T,Lf(t,cs),2*us},t.geoAzimuthalEqualArea=function(){return yd(Td).scale(124.75).clipAngle(179.999)},t.geoAzimuthalEqualAreaRaw=Td,t.geoAzimuthalEquidistant=function(){return yd(Ad).scale(79.4188).clipAngle(179.999)},t.geoAzimuthalEquidistantRaw=Ad,t.geoBounds=function(t){var n,e,r,i,o,a,u;if(Qf=Kf=-(Wf=Zf=1/0),is=[],Lf(t,Fs),e=is.length){for(is.sort(Hs),n=1,o=[r=is[0]];n<e;++n)Xs(r,(i=is[n])[0])||Xs(r,i[1])?(js(r[0],i[1])>js(r[0],r[1])&&(r[1]=i[1]),js(i[0],r[1])>js(r[0],r[1])&&(r[0]=i[0])):o.push(r=i);for(a=-1/0,n=0,r=o[e=o.length-1];n<=e;r=i,++n)i=o[n],(u=js(r[1],i[0]))>a&&(a=u,Wf=i[0],Kf=r[1])}return is=os=null,Wf===1/0||Zf===1/0?[[NaN,NaN],[NaN,NaN]]:[[Wf,Zf],[Kf,Qf]]},t.geoCentroid=function(t){ms=xs=ws=Ms=Ts=As=Ss=Es=0,Ns=new T,ks=new T,Cs=new T,Lf(t,Gs);var n=+Ns,e=+ks,r=+Cs,i=Ef(n,e,r);return i<pf&&(n=As,e=Ss,r=Es,xs<df&&(n=ws,e=Ms,r=Ts),(i=Ef(n,e,r))<pf)?[NaN,NaN]:[Mf(e,n)*bf,Rf(r/i)*bf]},t.geoCircle=function(){var t,n,e=il([0,0]),r=il(90),i=il(2),o={point:function(e,r){t.push(e=n(e,r)),e[0]*=bf,e[1]*=bf}};function a(){var a=e.apply(this,arguments),u=r.apply(this,arguments)*mf,c=i.apply(this,arguments)*mf;return t=[],n=ul(-a[0]*mf,-a[1]*mf,0).invert,hl(o,u,c,1),a={type:"Polygon",coordinates:[t]},t=n=null,a}return a.center=function(t){return arguments.length?(e="function"==typeof t?t:il([+t[0],+t[1]]),a):e},a.radius=function(t){return arguments.length?(r="function"==typeof t?t:il(+t),a):r},a.precision=function(t){return arguments.length?(i="function"==typeof t?t:il(+t),a):i},a},t.geoClipAntimeridian=Tl,t.geoClipCircle=Al,t.geoClipExtent=function(){var t,n,e,r=0,i=0,o=960,a=500;return e={stream:function(e){return t&&n===e?t:t=zl(r,i,o,a)(n=e)},extent:function(u){return arguments.length?(r=+u[0][0],i=+u[0][1],o=+u[1][0],a=+u[1][1],t=n=null,e):[[r,i],[o,a]]}}},t.geoClipRectangle=zl,t.geoConicConformal=function(){return _d(kd).scale(109.5).parallels([30,30])},t.geoConicConformalRaw=kd,t.geoConicEqualArea=md,t.geoConicEqualAreaRaw=bd,t.geoConicEquidistant=function(){return _d(Pd).scale(131.154).center([0,13.9389])},t.geoConicEquidistantRaw=Pd,t.geoContains=function(t,n){return(t&&Bl.hasOwnProperty(t.type)?Bl[t.type]:Ll)(t,n)},t.geoDistance=Ol,t.geoEqualEarth=function(){return yd(qd).scale(177.158)},t.geoEqualEarthRaw=qd,t.geoEquirectangular=function(){return yd(Cd).scale(152.63)},t.geoEquirectangularRaw=Cd,t.geoGnomonic=function(){return yd(Ud).scale(144.049).clipAngle(60)},t.geoGnomonicRaw=Ud,t.geoGraticule=Kl,t.geoGraticule10=function(){return Kl()()},t.geoIdentity=function(){var t,n,e,r,i,o,a,u=1,c=0,f=0,s=1,l=1,h=0,d=null,p=1,g=1,y=id({point:function(t,n){var e=b([t,n]);this.stream.point(e[0],e[1])}}),v=eh;function _(){return p=u*s,g=u*l,o=a=null,b}function b(e){var r=e[0]*p,i=e[1]*g;if(h){var o=i*t-r*n;r=r*t+i*n,i=o}return[r+c,i+f]}return b.invert=function(e){var r=e[0]-c,i=e[1]-f;if(h){var o=i*t+r*n;r=r*t-i*n,i=o}return[r/p,i/g]},b.stream=function(t){return o&&a===t?o:o=y(v(a=t))},b.postclip=function(t){return arguments.length?(v=t,d=e=r=i=null,_()):v},b.clipExtent=function(t){return arguments.length?(v=null==t?(d=e=r=i=null,eh):zl(d=+t[0][0],e=+t[0][1],r=+t[1][0],i=+t[1][1]),_()):null==d?null:[[d,e],[r,i]]},b.scale=function(t){return arguments.length?(u=+t,_()):u},b.translate=function(t){return arguments.length?(c=+t[0],f=+t[1],_()):[c,f]},b.angle=function(e){return arguments.length?(n=Cf(h=e%360*mf),t=Tf(h),_()):h*bf},b.reflectX=function(t){return arguments.length?(s=t?-1:1,_()):s<0},b.reflectY=function(t){return arguments.length?(l=t?-1:1,_()):l<0},b.fitExtent=function(t,n){return ud(b,t,n)},b.fitSize=function(t,n){return cd(b,t,n)},b.fitWidth=function(t,n){return fd(b,t,n)},b.fitHeight=function(t,n){return sd(b,t,n)},b},t.geoInterpolate=function(t,n){var e=t[0]*mf,r=t[1]*mf,i=n[0]*mf,o=n[1]*mf,a=Tf(r),u=Cf(r),c=Tf(o),f=Cf(o),s=a*Tf(e),l=a*Cf(e),h=c*Tf(i),d=c*Cf(i),p=2*Rf(zf(Ff(o-r)+a*c*Ff(i-e))),g=Cf(p),y=p?function(t){var n=Cf(t*=p)/g,e=Cf(p-t)/g,r=e*s+n*h,i=e*l+n*d,o=e*u+n*f;return[Mf(i,r)*bf,Mf(o,zf(r*r+i*i))*bf]}:function(){return[e*bf,r*bf]};return y.distance=p,y},t.geoLength=ql,t.geoMercator=function(){return Ed(Sd).scale(961/_f)},t.geoMercatorRaw=Sd,t.geoNaturalEarth1=function(){return yd(Id).scale(175.295)},t.geoNaturalEarth1Raw=Id,t.geoOrthographic=function(){return yd(Od).scale(249.5).clipAngle(90+df)},t.geoOrthographicRaw=Od,t.geoPath=function(t,n){let e,r,i=3,o=4.5;function a(t){return t&&("function"==typeof o&&r.pointRadius(+o.apply(this,arguments)),Lf(t,e(r))),r.result()}return a.area=function(t){return Lf(t,e(sh)),sh.result()},a.measure=function(t){return Lf(t,e(Kh)),Kh.result()},a.bounds=function(t){return Lf(t,e(mh)),mh.result()},a.centroid=function(t){return Lf(t,e(Oh)),Oh.result()},a.projection=function(n){return arguments.length?(e=null==n?(t=null,eh):(t=n).stream,a):t},a.context=function(t){return arguments.length?(r=null==t?(n=null,new ed(i)):new Bh(n=t),"function"!=typeof o&&r.pointRadius(o),a):n},a.pointRadius=function(t){return arguments.length?(o="function"==typeof t?t:(r.pointRadius(+t),+t),a):o},a.digits=function(t){if(!arguments.length)return i;if(null==t)i=null;else{const n=Math.floor(t);if(!(n>=0))throw new RangeError(`invalid digits: ${t}`);i=n}return null===n&&(r=new ed(i)),a},a.projection(t).digits(i).context(n)},t.geoProjection=yd,t.geoProjectionMutator=vd,t.geoRotation=ll,t.geoStereographic=function(){return yd(Bd).scale(250).clipAngle(142)},t.geoStereographicRaw=Bd,t.geoStream=Lf,t.geoTransform=function(t){return{stream:id(t)}},t.geoTransverseMercator=function(){var t=Ed(Yd),n=t.center,e=t.rotate;return t.center=function(t){return arguments.length?n([-t[1],t[0]]):[(t=n())[1],-t[0]]},t.rotate=function(t){return arguments.length?e([t[0],t[1],t.length>2?t[2]+90:90]):[(t=e())[0],t[1],t[2]-90]},e([0,0,90]).scale(159.155)},t.geoTransverseMercatorRaw=Yd,t.gray=function(t,n){return new ur(t,0,0,null==n?1:n)},t.greatest=ot,t.greatestIndex=function(t,e=n){if(1===e.length)return tt(t,e);let r,i=-1,o=-1;for(const n of t)++o,(i<0?0===e(n,n):e(n,r)>0)&&(r=n,i=o);return i},t.group=C,t.groupSort=function(t,e,r){return(2!==e.length?U($(t,e,r),(([t,e],[r,i])=>n(e,i)||n(t,r))):U(C(t,r),(([t,r],[i,o])=>e(r,o)||n(t,i)))).map((([t])=>t))},t.groups=P,t.hcl=dr,t.hierarchy=Gd,t.histogram=Q,t.hsl=He,t.html=Ec,t.image=function(t,n){return new Promise((function(e,r){var i=new Image;for(var o in n)i[o]=n[o];i.onerror=r,i.onload=function(){e(i)},i.src=t}))},t.index=function(t,...n){return F(t,k,R,n)},t.indexes=function(t,...n){return F(t,Array.from,R,n)},t.interpolate=Gr,t.interpolateArray=function(t,n){return(Ir(n)?Ur:Or)(t,n)},t.interpolateBasis=Er,t.interpolateBasisClosed=Nr,t.interpolateBlues=Gb,t.interpolateBrBG=ob,t.interpolateBuGn=Mb,t.interpolateBuPu=Ab,t.interpolateCividis=function(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-t*(35.34-t*(2381.73-t*(6402.7-t*(7024.72-2710.57*t)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+t*(170.73+t*(52.82-t*(131.46-t*(176.58-67.37*t)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+t*(442.36-t*(2482.43-t*(6167.24-t*(6614.94-2475.67*t)))))))+")"},t.interpolateCool=am,t.interpolateCubehelix=li,t.interpolateCubehelixDefault=im,t.interpolateCubehelixLong=hi,t.interpolateDate=Br,t.interpolateDiscrete=function(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}},t.interpolateGnBu=Eb,t.interpolateGreens=Wb,t.interpolateGreys=Kb,t.interpolateHcl=ci,t.interpolateHclLong=fi,t.interpolateHsl=oi,t.interpolateHslLong=ai,t.interpolateHue=function(t,n){var e=Pr(+t,+n);return function(t){var n=e(t);return n-360*Math.floor(n/360)}},t.interpolateInferno=pm,t.interpolateLab=function(t,n){var e=$r((t=ar(t)).l,(n=ar(n)).l),r=$r(t.a,n.a),i=$r(t.b,n.b),o=$r(t.opacity,n.opacity);return function(n){return t.l=e(n),t.a=r(n),t.b=i(n),t.opacity=o(n),t+""}},t.interpolateMagma=dm,t.interpolateNumber=Yr,t.interpolateNumberArray=Ur,t.interpolateObject=Lr,t.interpolateOrRd=kb,t.interpolateOranges=rm,t.interpolatePRGn=ub,t.interpolatePiYG=fb,t.interpolatePlasma=gm,t.interpolatePuBu=$b,t.interpolatePuBuGn=Pb,t.interpolatePuOr=lb,t.interpolatePuRd=Rb,t.interpolatePurples=Jb,t.interpolateRainbow=function(t){(t<0||t>1)&&(t-=Math.floor(t));var n=Math.abs(t-.5);return um.h=360*t-100,um.s=1.5-1.5*n,um.l=.8-.9*n,um+""},t.interpolateRdBu=db,t.interpolateRdGy=gb,t.interpolateRdPu=qb,t.interpolateRdYlBu=vb,t.interpolateRdYlGn=bb,t.interpolateReds=nm,t.interpolateRgb=Dr,t.interpolateRgbBasis=Fr,t.interpolateRgbBasisClosed=qr,t.interpolateRound=Vr,t.interpolateSinebow=function(t){var n;return t=(.5-t)*Math.PI,cm.r=255*(n=Math.sin(t))*n,cm.g=255*(n=Math.sin(t+fm))*n,cm.b=255*(n=Math.sin(t+sm))*n,cm+""},t.interpolateSpectral=xb,t.interpolateString=Xr,t.interpolateTransformCss=ti,t.interpolateTransformSvg=ni,t.interpolateTurbo=function(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+t*(1172.33-t*(10793.56-t*(33300.12-t*(38394.49-14825.05*t)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+t*(557.33+t*(1225.33-t*(3574.96-t*(1073.77+707.56*t)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+t*(3211.1-t*(15327.97-t*(27814-t*(22569.18-6838.66*t)))))))+")"},t.interpolateViridis=hm,t.interpolateWarm=om,t.interpolateYlGn=Bb,t.interpolateYlGnBu=Ib,t.interpolateYlOrBr=Lb,t.interpolateYlOrRd=Hb,t.interpolateZoom=ri,t.interrupt=Gi,t.intersection=function(t,...n){t=new InternSet(t),n=n.map(vt);t:for(const e of t)for(const r of n)if(!r.has(e)){t.delete(e);continue t}return t},t.interval=function(t,n,e){var r=new Ei,i=n;return null==n?(r.restart(t,n,e),r):(r._restart=r.restart,r.restart=function(t,n,e){n=+n,e=null==e?Ai():+e,r._restart((function o(a){a+=i,r._restart(o,i+=n,e),t(a)}),n,e)},r.restart(t,n,e),r)},t.isoFormat=D_,t.isoParse=F_,t.json=function(t,n){return fetch(t,n).then(Tc)},t.lab=ar,t.lch=function(t,n,e,r){return 1===arguments.length?hr(t):new pr(e,n,t,null==r?1:r)},t.least=function(t,e=n){let r,i=!1;if(1===e.length){let o;for(const a of t){const t=e(a);(i?n(t,o)<0:0===n(t,t))&&(r=a,o=t,i=!0)}}else for(const n of t)(i?e(n,r)<0:0===e(n,n))&&(r=n,i=!0);return r},t.leastIndex=ht,t.line=Ym,t.lineRadial=Zm,t.link=ax,t.linkHorizontal=function(){return ax(nx)},t.linkRadial=function(){const t=ax(rx);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},t.linkVertical=function(){return ax(ex)},t.local=Qn,t.map=function(t,n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");if("function"!=typeof n)throw new TypeError("mapper is not a function");return Array.from(t,((e,r)=>n(e,r,t)))},t.matcher=Vt,t.max=J,t.maxIndex=tt,t.mean=function(t,n){let e=0,r=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(++e,r+=n);else{let i=-1;for(let o of t)null!=(o=n(o,++i,t))&&(o=+o)>=o&&(++e,r+=o)}if(e)return r/e},t.median=function(t,n){return at(t,.5,n)},t.medianIndex=function(t,n){return ct(t,.5,n)},t.merge=ft,t.min=nt,t.minIndex=et,t.mode=function(t,n){const e=new InternMap;if(void 0===n)for(let n of t)null!=n&&n>=n&&e.set(n,(e.get(n)||0)+1);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&i>=i&&e.set(i,(e.get(i)||0)+1)}let r,i=0;for(const[t,n]of e)n>i&&(i=n,r=t);return r},t.namespace=It,t.namespaces=Ut,t.nice=Z,t.now=Ai,t.pack=function(){var t=null,n=1,e=1,r=np;function i(i){const o=ap();return i.x=n/2,i.y=e/2,t?i.eachBefore(xp(t)).eachAfter(wp(r,.5,o)).eachBefore(Mp(1)):i.eachBefore(xp(mp)).eachAfter(wp(np,1,o)).eachAfter(wp(r,i.r/Math.min(n,e),o)).eachBefore(Mp(Math.min(n,e)/(2*i.r))),i}return i.radius=function(n){return arguments.length?(t=Jd(n),i):t},i.size=function(t){return arguments.length?(n=+t[0],e=+t[1],i):[n,e]},i.padding=function(t){return arguments.length?(r="function"==typeof t?t:ep(+t),i):r},i},t.packEnclose=function(t){return up(t,ap())},t.packSiblings=function(t){return bp(t,ap()),t},t.pairs=function(t,n=st){const e=[];let r,i=!1;for(const o of t)i&&e.push(n(r,o)),r=o,i=!0;return e},t.partition=function(){var t=1,n=1,e=0,r=!1;function i(i){var o=i.height+1;return i.x0=i.y0=e,i.x1=t,i.y1=n/o,i.eachBefore(function(t,n){return function(r){r.children&&Ap(r,r.x0,t*(r.depth+1)/n,r.x1,t*(r.depth+2)/n);var i=r.x0,o=r.y0,a=r.x1-e,u=r.y1-e;a<i&&(i=a=(i+a)/2),u<o&&(o=u=(o+u)/2),r.x0=i,r.y0=o,r.x1=a,r.y1=u}}(n,o)),r&&i.eachBefore(Tp),i}return i.round=function(t){return arguments.length?(r=!!t,i):r},i.size=function(e){return arguments.length?(t=+e[0],n=+e[1],i):[t,n]},i.padding=function(t){return arguments.length?(e=+t,i):e},i},t.path=Ia,t.pathRound=function(t=3){return new Ua(+t)},t.permute=q,t.pie=function(){var t=Hm,n=jm,e=null,r=ym(0),i=ym(Em),o=ym(0);function a(a){var u,c,f,s,l,h=(a=qm(a)).length,d=0,p=new Array(h),g=new Array(h),y=+r.apply(this,arguments),v=Math.min(Em,Math.max(-Em,i.apply(this,arguments)-y)),_=Math.min(Math.abs(v)/h,o.apply(this,arguments)),b=_*(v<0?-1:1);for(u=0;u<h;++u)(l=g[p[u]=u]=+t(a[u],u,a))>0&&(d+=l);for(null!=n?p.sort((function(t,e){return n(g[t],g[e])})):null!=e&&p.sort((function(t,n){return e(a[t],a[n])})),u=0,f=d?(v-h*b)/d:0;u<h;++u,y=s)c=p[u],s=y+((l=g[c])>0?l*f:0)+b,g[c]={data:a[c],index:u,value:l,startAngle:y,endAngle:s,padAngle:_};return g}return a.value=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),a):t},a.sortValues=function(t){return arguments.length?(n=t,e=null,a):n},a.sort=function(t){return arguments.length?(e=t,n=null,a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:ym(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:ym(+t),a):i},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:ym(+t),a):o},a},t.piecewise=di,t.pointRadial=Qm,t.pointer=ne,t.pointers=function(t,n){return t.target&&(t=te(t),void 0===n&&(n=t.currentTarget),t=t.touches||[t]),Array.from(t,(t=>ne(t,n)))},t.polygonArea=function(t){for(var n,e=-1,r=t.length,i=t[r-1],o=0;++e<r;)n=i,i=t[e],o+=n[1]*i[0]-n[0]*i[1];return o/2},t.polygonCentroid=function(t){for(var n,e,r=-1,i=t.length,o=0,a=0,u=t[i-1],c=0;++r<i;)n=u,u=t[r],c+=e=n[0]*u[1]-u[0]*n[1],o+=(n[0]+u[0])*e,a+=(n[1]+u[1])*e;return[o/(c*=3),a/c]},t.polygonContains=function(t,n){for(var e,r,i=t.length,o=t[i-1],a=n[0],u=n[1],c=o[0],f=o[1],s=!1,l=0;l<i;++l)e=(o=t[l])[0],(r=o[1])>u!=f>u&&a<(c-e)*(u-r)/(f-r)+e&&(s=!s),c=e,f=r;return s},t.polygonHull=function(t){if((e=t.length)<3)return null;var n,e,r=new Array(e),i=new Array(e);for(n=0;n<e;++n)r[n]=[+t[n][0],+t[n][1],n];for(r.sort(Hp),n=0;n<e;++n)i[n]=[r[n][0],-r[n][1]];var o=Xp(r),a=Xp(i),u=a[0]===o[0],c=a[a.length-1]===o[o.length-1],f=[];for(n=o.length-1;n>=0;--n)f.push(t[r[o[n]][2]]);for(n=+u;n<a.length-c;++n)f.push(t[r[a[n]][2]]);return f},t.polygonLength=function(t){for(var n,e,r=-1,i=t.length,o=t[i-1],a=o[0],u=o[1],c=0;++r<i;)n=a,e=u,n-=a=(o=t[r])[0],e-=u=o[1],c+=Math.hypot(n,e);return c},t.precisionFixed=sf,t.precisionPrefix=lf,t.precisionRound=hf,t.quadtree=$c,t.quantile=at,t.quantileIndex=ct,t.quantileSorted=ut,t.quantize=function(t,n){for(var e=new Array(n),r=0;r<n;++r)e[r]=t(r/(n-1));return e},t.quickselect=rt,t.radialArea=Km,t.radialLine=Zm,t.randomBates=Jp,t.randomBernoulli=eg,t.randomBeta=og,t.randomBinomial=ag,t.randomCauchy=cg,t.randomExponential=tg,t.randomGamma=ig,t.randomGeometric=rg,t.randomInt=Wp,t.randomIrwinHall=Qp,t.randomLcg=function(t=Math.random()){let n=0|(0<=t&&t<1?t/lg:Math.abs(t));return()=>(n=1664525*n+1013904223|0,lg*(n>>>0))},t.randomLogNormal=Kp,t.randomLogistic=fg,t.randomNormal=Zp,t.randomPareto=ng,t.randomPoisson=sg,t.randomUniform=Vp,t.randomWeibull=ug,t.range=lt,t.rank=function(t,e=n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");let r=Array.from(t);const i=new Float64Array(r.length);2!==e.length&&(r=r.map(e),e=n);const o=(t,n)=>e(r[t],r[n]);let a,u;return(t=Uint32Array.from(r,((t,n)=>n))).sort(e===n?(t,n)=>O(r[t],r[n]):I(o)),t.forEach(((t,n)=>{const e=o(t,void 0===a?t:a);e>=0?((void 0===a||e>0)&&(a=t,u=n),i[t]=u):i[t]=NaN})),i},t.reduce=function(t,n,e){if("function"!=typeof n)throw new TypeError("reducer is not a function");const r=t[Symbol.iterator]();let i,o,a=-1;if(arguments.length<3){if(({done:i,value:e}=r.next()),i)return;++a}for(;({done:i,value:o}=r.next()),!i;)e=n(e,o,++a,t);return e},t.reverse=function(t){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");return Array.from(t).reverse()},t.rgb=Fe,t.ribbon=function(){return Wa()},t.ribbonArrow=function(){return Wa(Va)},t.rollup=$,t.rollups=D,t.scaleBand=yg,t.scaleDiverging=function t(){var n=Ng(L_()(mg));return n.copy=function(){return B_(n,t())},dg.apply(n,arguments)},t.scaleDivergingLog=function t(){var n=Fg(L_()).domain([.1,1,10]);return n.copy=function(){return B_(n,t()).base(n.base())},dg.apply(n,arguments)},t.scaleDivergingPow=j_,t.scaleDivergingSqrt=function(){return j_.apply(null,arguments).exponent(.5)},t.scaleDivergingSymlog=function t(){var n=Ig(L_());return n.copy=function(){return B_(n,t()).constant(n.constant())},dg.apply(n,arguments)},t.scaleIdentity=function t(n){var e;function r(t){return null==t||isNaN(t=+t)?e:t}return r.invert=r,r.domain=r.range=function(t){return arguments.length?(n=Array.from(t,_g),r):n.slice()},r.unknown=function(t){return arguments.length?(e=t,r):e},r.copy=function(){return t(n).unknown(e)},n=arguments.length?Array.from(n,_g):[0,1],Ng(r)},t.scaleImplicit=pg,t.scaleLinear=function t(){var n=Sg();return n.copy=function(){return Tg(n,t())},hg.apply(n,arguments),Ng(n)},t.scaleLog=function t(){const n=Fg(Ag()).domain([1,10]);return n.copy=()=>Tg(n,t()).base(n.base()),hg.apply(n,arguments),n},t.scaleOrdinal=gg,t.scalePoint=function(){return vg(yg.apply(null,arguments).paddingInner(1))},t.scalePow=jg,t.scaleQuantile=function t(){var e,r=[],i=[],o=[];function a(){var t=0,n=Math.max(1,i.length);for(o=new Array(n-1);++t<n;)o[t-1]=ut(r,t/n);return u}function u(t){return null==t||isNaN(t=+t)?e:i[s(o,t)]}return u.invertExtent=function(t){var n=i.indexOf(t);return n<0?[NaN,NaN]:[n>0?o[n-1]:r[0],n<o.length?o[n]:r[r.length-1]]},u.domain=function(t){if(!arguments.length)return r.slice();r=[];for(let n of t)null==n||isNaN(n=+n)||r.push(n);return r.sort(n),a()},u.range=function(t){return arguments.length?(i=Array.from(t),a()):i.slice()},u.unknown=function(t){return arguments.length?(e=t,u):e},u.quantiles=function(){return o.slice()},u.copy=function(){return t().domain(r).range(i).unknown(e)},hg.apply(u,arguments)},t.scaleQuantize=function t(){var n,e=0,r=1,i=1,o=[.5],a=[0,1];function u(t){return null!=t&&t<=t?a[s(o,t,0,i)]:n}function c(){var t=-1;for(o=new Array(i);++t<i;)o[t]=((t+1)*r-(t-i)*e)/(i+1);return u}return u.domain=function(t){return arguments.length?([e,r]=t,e=+e,r=+r,c()):[e,r]},u.range=function(t){return arguments.length?(i=(a=Array.from(t)).length-1,c()):a.slice()},u.invertExtent=function(t){var n=a.indexOf(t);return n<0?[NaN,NaN]:n<1?[e,o[0]]:n>=i?[o[i-1],r]:[o[n-1],o[n]]},u.unknown=function(t){return arguments.length?(n=t,u):u},u.thresholds=function(){return o.slice()},u.copy=function(){return t().domain([e,r]).range(a).unknown(n)},hg.apply(Ng(u),arguments)},t.scaleRadial=function t(){var n,e=Sg(),r=[0,1],i=!1;function o(t){var r=function(t){return Math.sign(t)*Math.sqrt(Math.abs(t))}(e(t));return isNaN(r)?n:i?Math.round(r):r}return o.invert=function(t){return e.invert(Hg(t))},o.domain=function(t){return arguments.length?(e.domain(t),o):e.domain()},o.range=function(t){return arguments.length?(e.range((r=Array.from(t,_g)).map(Hg)),o):r.slice()},o.rangeRound=function(t){return o.range(t).round(!0)},o.round=function(t){return arguments.length?(i=!!t,o):i},o.clamp=function(t){return arguments.length?(e.clamp(t),o):e.clamp()},o.unknown=function(t){return arguments.length?(n=t,o):n},o.copy=function(){return t(e.domain(),r).round(i).clamp(e.clamp()).unknown(n)},hg.apply(o,arguments),Ng(o)},t.scaleSequential=function t(){var n=Ng(O_()(mg));return n.copy=function(){return B_(n,t())},dg.apply(n,arguments)},t.scaleSequentialLog=function t(){var n=Fg(O_()).domain([1,10]);return n.copy=function(){return B_(n,t()).base(n.base())},dg.apply(n,arguments)},t.scaleSequentialPow=Y_,t.scaleSequentialQuantile=function t(){var e=[],r=mg;function i(t){if(null!=t&&!isNaN(t=+t))return r((s(e,t,1)-1)/(e.length-1))}return i.domain=function(t){if(!arguments.length)return e.slice();e=[];for(let n of t)null==n||isNaN(n=+n)||e.push(n);return e.sort(n),i},i.interpolator=function(t){return arguments.length?(r=t,i):r},i.range=function(){return e.map(((t,n)=>r(n/(e.length-1))))},i.quantiles=function(t){return Array.from({length:t+1},((n,r)=>at(e,r/t)))},i.copy=function(){return t(r).domain(e)},dg.apply(i,arguments)},t.scaleSequentialSqrt=function(){return Y_.apply(null,arguments).exponent(.5)},t.scaleSequentialSymlog=function t(){var n=Ig(O_());return n.copy=function(){return B_(n,t()).constant(n.constant())},dg.apply(n,arguments)},t.scaleSqrt=function(){return jg.apply(null,arguments).exponent(.5)},t.scaleSymlog=function t(){var n=Ig(Ag());return n.copy=function(){return Tg(n,t()).constant(n.constant())},hg.apply(n,arguments)},t.scaleThreshold=function t(){var n,e=[.5],r=[0,1],i=1;function o(t){return null!=t&&t<=t?r[s(e,t,0,i)]:n}return o.domain=function(t){return arguments.length?(e=Array.from(t),i=Math.min(e.length,r.length-1),o):e.slice()},o.range=function(t){return arguments.length?(r=Array.from(t),i=Math.min(e.length,r.length-1),o):r.slice()},o.invertExtent=function(t){var n=r.indexOf(t);return[e[n-1],e[n]]},o.unknown=function(t){return arguments.length?(n=t,o):n},o.copy=function(){return t().domain(e).range(r).unknown(n)},hg.apply(o,arguments)},t.scaleTime=function(){return hg.apply(I_(uv,cv,tv,Zy,xy,py,sy,ay,iy,t.timeFormat).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)},t.scaleUtc=function(){return hg.apply(I_(ov,av,ev,Qy,Fy,yy,hy,cy,iy,t.utcFormat).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)},t.scan=function(t,n){const e=ht(t,n);return e<0?void 0:e},t.schemeAccent=G_,t.schemeBlues=Xb,t.schemeBrBG=ib,t.schemeBuGn=wb,t.schemeBuPu=Tb,t.schemeCategory10=X_,t.schemeDark2=V_,t.schemeGnBu=Sb,t.schemeGreens=Vb,t.schemeGreys=Zb,t.schemeObservable10=W_,t.schemeOrRd=Nb,t.schemeOranges=em,t.schemePRGn=ab,t.schemePaired=Z_,t.schemePastel1=K_,t.schemePastel2=Q_,t.schemePiYG=cb,t.schemePuBu=zb,t.schemePuBuGn=Cb,t.schemePuOr=sb,t.schemePuRd=Db,t.schemePurples=Qb,t.schemeRdBu=hb,t.schemeRdGy=pb,t.schemeRdPu=Fb,t.schemeRdYlBu=yb,t.schemeRdYlGn=_b,t.schemeReds=tm,t.schemeSet1=J_,t.schemeSet2=tb,t.schemeSet3=nb,t.schemeSpectral=mb,t.schemeTableau10=eb,t.schemeYlGn=Ob,t.schemeYlGnBu=Ub,t.schemeYlOrBr=Yb,t.schemeYlOrRd=jb,t.select=Zn,t.selectAll=function(t){return"string"==typeof t?new Vn([document.querySelectorAll(t)],[document.documentElement]):new Vn([Ht(t)],Gn)},t.selection=Wn,t.selector=jt,t.selectorAll=Gt,t.shuffle=dt,t.shuffler=pt,t.some=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");let e=-1;for(const r of t)if(n(r,++e,t))return!0;return!1},t.sort=U,t.stack=function(){var t=ym([]),n=dw,e=hw,r=pw;function i(i){var o,a,u=Array.from(t.apply(this,arguments),gw),c=u.length,f=-1;for(const t of i)for(o=0,++f;o<c;++o)(u[o][f]=[0,+r(t,u[o].key,f,i)]).data=t;for(o=0,a=qm(n(u));o<c;++o)u[a[o]].index=o;return e(u,a),u}return i.keys=function(n){return arguments.length?(t="function"==typeof n?n:ym(Array.from(n)),i):t},i.value=function(t){return arguments.length?(r="function"==typeof t?t:ym(+t),i):r},i.order=function(t){return arguments.length?(n=null==t?dw:"function"==typeof t?t:ym(Array.from(t)),i):n},i.offset=function(t){return arguments.length?(e=null==t?hw:t,i):e},i},t.stackOffsetDiverging=function(t,n){if((u=t.length)>0)for(var e,r,i,o,a,u,c=0,f=t[n[0]].length;c<f;++c)for(o=a=0,e=0;e<u;++e)(i=(r=t[n[e]][c])[1]-r[0])>0?(r[0]=o,r[1]=o+=i):i<0?(r[1]=a,r[0]=a+=i):(r[0]=0,r[1]=i)},t.stackOffsetExpand=function(t,n){if((r=t.length)>0){for(var e,r,i,o=0,a=t[0].length;o<a;++o){for(i=e=0;e<r;++e)i+=t[e][o][1]||0;if(i)for(e=0;e<r;++e)t[e][o][1]/=i}hw(t,n)}},t.stackOffsetNone=hw,t.stackOffsetSilhouette=function(t,n){if((e=t.length)>0){for(var e,r=0,i=t[n[0]],o=i.length;r<o;++r){for(var a=0,u=0;a<e;++a)u+=t[a][r][1]||0;i[r][1]+=i[r][0]=-u/2}hw(t,n)}},t.stackOffsetWiggle=function(t,n){if((i=t.length)>0&&(r=(e=t[n[0]]).length)>0){for(var e,r,i,o=0,a=1;a<r;++a){for(var u=0,c=0,f=0;u<i;++u){for(var s=t[n[u]],l=s[a][1]||0,h=(l-(s[a-1][1]||0))/2,d=0;d<u;++d){var p=t[n[d]];h+=(p[a][1]||0)-(p[a-1][1]||0)}c+=l,f+=h*l}e[a-1][1]+=e[a-1][0]=o,c&&(o-=f/c)}e[a-1][1]+=e[a-1][0]=o,hw(t,n)}},t.stackOrderAppearance=yw,t.stackOrderAscending=_w,t.stackOrderDescending=function(t){return _w(t).reverse()},t.stackOrderInsideOut=function(t){var n,e,r=t.length,i=t.map(bw),o=yw(t),a=0,u=0,c=[],f=[];for(n=0;n<r;++n)e=o[n],a<u?(a+=i[e],c.push(e)):(u+=i[e],f.push(e));return f.reverse().concat(c)},t.stackOrderNone=dw,t.stackOrderReverse=function(t){return dw(t).reverse()},t.stratify=function(){var t,n=kp,e=Cp;function r(r){var i,o,a,u,c,f,s,l,h=Array.from(r),d=n,p=e,g=new Map;if(null!=t){const n=h.map(((n,e)=>function(t){t=`${t}`;let n=t.length;zp(t,n-1)&&!zp(t,n-2)&&(t=t.slice(0,-1));return"/"===t[0]?t:`/${t}`}(t(n,e,r)))),e=n.map(Pp),i=new Set(n).add("");for(const t of e)i.has(t)||(i.add(t),n.push(t),e.push(Pp(t)),h.push(Np));d=(t,e)=>n[e],p=(t,n)=>e[n]}for(a=0,i=h.length;a<i;++a)o=h[a],f=h[a]=new Qd(o),null!=(s=d(o,a,r))&&(s+="")&&(l=f.id=s,g.set(l,g.has(l)?Ep:f)),null!=(s=p(o,a,r))&&(s+="")&&(f.parent=s);for(a=0;a<i;++a)if(s=(f=h[a]).parent){if(!(c=g.get(s)))throw new Error("missing: "+s);if(c===Ep)throw new Error("ambiguous: "+s);c.children?c.children.push(f):c.children=[f],f.parent=c}else{if(u)throw new Error("multiple roots");u=f}if(!u)throw new Error("no root");if(null!=t){for(;u.data===Np&&1===u.children.length;)u=u.children[0],--i;for(let t=h.length-1;t>=0&&(f=h[t]).data===Np;--t)f.data=null}if(u.parent=Sp,u.eachBefore((function(t){t.depth=t.parent.depth+1,--i})).eachBefore(Kd),u.parent=null,i>0)throw new Error("cycle");return u}return r.id=function(t){return arguments.length?(n=Jd(t),r):n},r.parentId=function(t){return arguments.length?(e=Jd(t),r):e},r.path=function(n){return arguments.length?(t=Jd(n),r):t},r},t.style=_n,t.subset=function(t,n){return _t(n,t)},t.sum=function(t,n){let e=0;if(void 0===n)for(let n of t)(n=+n)&&(e+=n);else{let r=-1;for(let i of t)(i=+n(i,++r,t))&&(e+=i)}return e},t.superset=_t,t.svg=Nc,t.symbol=function(t,n){let e=null,r=km(i);function i(){let i;if(e||(e=i=r()),t.apply(this,arguments).draw(e,+n.apply(this,arguments)),i)return e=null,i+""||null}return t="function"==typeof t?t:ym(t||fx),n="function"==typeof n?n:ym(void 0===n?64:+n),i.type=function(n){return arguments.length?(t="function"==typeof n?n:ym(n),i):t},i.size=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),i):n},i.context=function(t){return arguments.length?(e=null==t?null:t,i):e},i},t.symbolAsterisk=cx,t.symbolCircle=fx,t.symbolCross=sx,t.symbolDiamond=dx,t.symbolDiamond2=px,t.symbolPlus=gx,t.symbolSquare=yx,t.symbolSquare2=vx,t.symbolStar=xx,t.symbolTimes=Px,t.symbolTriangle=Mx,t.symbolTriangle2=Ax,t.symbolWye=Cx,t.symbolX=Px,t.symbols=zx,t.symbolsFill=zx,t.symbolsStroke=$x,t.text=mc,t.thresholdFreedmanDiaconis=function(t,n,e){const r=v(t),i=at(t,.75)-at(t,.25);return r&&i?Math.ceil((e-n)/(2*i*Math.pow(r,-1/3))):1},t.thresholdScott=function(t,n,e){const r=v(t),i=w(t);return r&&i?Math.ceil((e-n)*Math.cbrt(r)/(3.49*i)):1},t.thresholdSturges=K,t.tickFormat=Eg,t.tickIncrement=V,t.tickStep=W,t.ticks=G,t.timeDay=py,t.timeDays=gy,t.timeFormatDefaultLocale=P_,t.timeFormatLocale=hv,t.timeFriday=Sy,t.timeFridays=$y,t.timeHour=sy,t.timeHours=ly,t.timeInterval=Vg,t.timeMillisecond=Wg,t.timeMilliseconds=Zg,t.timeMinute=ay,t.timeMinutes=uy,t.timeMonday=wy,t.timeMondays=ky,t.timeMonth=Zy,t.timeMonths=Ky,t.timeSaturday=Ey,t.timeSaturdays=Dy,t.timeSecond=iy,t.timeSeconds=oy,t.timeSunday=xy,t.timeSundays=Ny,t.timeThursday=Ay,t.timeThursdays=zy,t.timeTickInterval=cv,t.timeTicks=uv,t.timeTuesday=My,t.timeTuesdays=Cy,t.timeWednesday=Ty,t.timeWednesdays=Py,t.timeWeek=xy,t.timeWeeks=Ny,t.timeYear=tv,t.timeYears=nv,t.timeout=$i,t.timer=Ni,t.timerFlush=ki,t.transition=go,t.transpose=gt,t.tree=function(){var t=$p,n=1,e=1,r=null;function i(i){var c=function(t){for(var n,e,r,i,o,a=new Up(t,0),u=[a];n=u.pop();)if(r=n._.children)for(n.children=new Array(o=r.length),i=o-1;i>=0;--i)u.push(e=n.children[i]=new Up(r[i],i)),e.parent=n;return(a.parent=new Up(null,0)).children=[a],a}(i);if(c.eachAfter(o),c.parent.m=-c.z,c.eachBefore(a),r)i.eachBefore(u);else{var f=i,s=i,l=i;i.eachBefore((function(t){t.x<f.x&&(f=t),t.x>s.x&&(s=t),t.depth>l.depth&&(l=t)}));var h=f===s?1:t(f,s)/2,d=h-f.x,p=n/(s.x+h+d),g=e/(l.depth||1);i.eachBefore((function(t){t.x=(t.x+d)*p,t.y=t.depth*g}))}return i}function o(n){var e=n.children,r=n.parent.children,i=n.i?r[n.i-1]:null;if(e){!function(t){for(var n,e=0,r=0,i=t.children,o=i.length;--o>=0;)(n=i[o]).z+=e,n.m+=e,e+=n.s+(r+=n.c)}(n);var o=(e[0].z+e[e.length-1].z)/2;i?(n.z=i.z+t(n._,i._),n.m=n.z-o):n.z=o}else i&&(n.z=i.z+t(n._,i._));n.parent.A=function(n,e,r){if(e){for(var i,o=n,a=n,u=e,c=o.parent.children[0],f=o.m,s=a.m,l=u.m,h=c.m;u=Rp(u),o=Dp(o),u&&o;)c=Dp(c),(a=Rp(a)).a=n,(i=u.z+l-o.z-f+t(u._,o._))>0&&(Fp(qp(u,n,r),n,i),f+=i,s+=i),l+=u.m,f+=o.m,h+=c.m,s+=a.m;u&&!Rp(a)&&(a.t=u,a.m+=l-s),o&&!Dp(c)&&(c.t=o,c.m+=f-h,r=n)}return r}(n,i,n.parent.A||r[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function u(t){t.x*=n,t.y=t.depth*e}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.treemap=function(){var t=Yp,n=!1,e=1,r=1,i=[0],o=np,a=np,u=np,c=np,f=np;function s(t){return t.x0=t.y0=0,t.x1=e,t.y1=r,t.eachBefore(l),i=[0],n&&t.eachBefore(Tp),t}function l(n){var e=i[n.depth],r=n.x0+e,s=n.y0+e,l=n.x1-e,h=n.y1-e;l<r&&(r=l=(r+l)/2),h<s&&(s=h=(s+h)/2),n.x0=r,n.y0=s,n.x1=l,n.y1=h,n.children&&(e=i[n.depth+1]=o(n)/2,r+=f(n)-e,s+=a(n)-e,(l-=u(n)-e)<r&&(r=l=(r+l)/2),(h-=c(n)-e)<s&&(s=h=(s+h)/2),t(n,r,s,l,h))}return s.round=function(t){return arguments.length?(n=!!t,s):n},s.size=function(t){return arguments.length?(e=+t[0],r=+t[1],s):[e,r]},s.tile=function(n){return arguments.length?(t=tp(n),s):t},s.padding=function(t){return arguments.length?s.paddingInner(t).paddingOuter(t):s.paddingInner()},s.paddingInner=function(t){return arguments.length?(o="function"==typeof t?t:ep(+t),s):o},s.paddingOuter=function(t){return arguments.length?s.paddingTop(t).paddingRight(t).paddingBottom(t).paddingLeft(t):s.paddingTop()},s.paddingTop=function(t){return arguments.length?(a="function"==typeof t?t:ep(+t),s):a},s.paddingRight=function(t){return arguments.length?(u="function"==typeof t?t:ep(+t),s):u},s.paddingBottom=function(t){return arguments.length?(c="function"==typeof t?t:ep(+t),s):c},s.paddingLeft=function(t){return arguments.length?(f="function"==typeof t?t:ep(+t),s):f},s},t.treemapBinary=function(t,n,e,r,i){var o,a,u=t.children,c=u.length,f=new Array(c+1);for(f[0]=a=o=0;o<c;++o)f[o+1]=a+=u[o].value;!function t(n,e,r,i,o,a,c){if(n>=e-1){var s=u[n];return s.x0=i,s.y0=o,s.x1=a,void(s.y1=c)}var l=f[n],h=r/2+l,d=n+1,p=e-1;for(;d<p;){var g=d+p>>>1;f[g]<h?d=g+1:p=g}h-f[d-1]<f[d]-h&&n+1<d&&--d;var y=f[d]-l,v=r-y;if(a-i>c-o){var _=r?(i*v+a*y)/r:a;t(n,d,y,i,o,_,c),t(d,e,v,_,o,a,c)}else{var b=r?(o*v+c*y)/r:c;t(n,d,y,i,o,a,b),t(d,e,v,i,b,a,c)}}(0,c,t.value,n,e,r,i)},t.treemapDice=Ap,t.treemapResquarify=Lp,t.treemapSlice=Ip,t.treemapSliceDice=function(t,n,e,r,i){(1&t.depth?Ip:Ap)(t,n,e,r,i)},t.treemapSquarify=Yp,t.tsv=Mc,t.tsvFormat=lc,t.tsvFormatBody=hc,t.tsvFormatRow=pc,t.tsvFormatRows=dc,t.tsvFormatValue=gc,t.tsvParse=fc,t.tsvParseRows=sc,t.union=function(...t){const n=new InternSet;for(const e of t)for(const t of e)n.add(t);return n},t.unixDay=_y,t.unixDays=by,t.utcDay=yy,t.utcDays=vy,t.utcFriday=By,t.utcFridays=Vy,t.utcHour=hy,t.utcHours=dy,t.utcMillisecond=Wg,t.utcMilliseconds=Zg,t.utcMinute=cy,t.utcMinutes=fy,t.utcMonday=qy,t.utcMondays=jy,t.utcMonth=Qy,t.utcMonths=Jy,t.utcSaturday=Yy,t.utcSaturdays=Wy,t.utcSecond=iy,t.utcSeconds=oy,t.utcSunday=Fy,t.utcSundays=Ly,t.utcThursday=Oy,t.utcThursdays=Gy,t.utcTickInterval=av,t.utcTicks=ov,t.utcTuesday=Uy,t.utcTuesdays=Hy,t.utcWednesday=Iy,t.utcWednesdays=Xy,t.utcWeek=Fy,t.utcWeeks=Ly,t.utcYear=ev,t.utcYears=rv,t.variance=x,t.version="7.9.0",t.window=pn,t.xml=Sc,t.zip=function(){return gt(arguments)},t.zoom=function(){var t,n,e,r=Ew,i=Nw,o=zw,a=Cw,u=Pw,c=[0,1/0],f=[[-1/0,-1/0],[1/0,1/0]],s=250,l=ri,h=$t("start","zoom","end"),d=500,p=150,g=0,y=10;function v(t){t.property("__zoom",kw).on("wheel.zoom",T,{passive:!1}).on("mousedown.zoom",A).on("dblclick.zoom",S).filter(u).on("touchstart.zoom",E).on("touchmove.zoom",N).on("touchend.zoom touchcancel.zoom",k).style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function _(t,n){return(n=Math.max(c[0],Math.min(c[1],n)))===t.k?t:new ww(n,t.x,t.y)}function b(t,n,e){var r=n[0]-e[0]*t.k,i=n[1]-e[1]*t.k;return r===t.x&&i===t.y?t:new ww(t.k,r,i)}function m(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function x(t,n,e,r){t.on("start.zoom",(function(){w(this,arguments).event(r).start()})).on("interrupt.zoom end.zoom",(function(){w(this,arguments).event(r).end()})).tween("zoom",(function(){var t=this,o=arguments,a=w(t,o).event(r),u=i.apply(t,o),c=null==e?m(u):"function"==typeof e?e.apply(t,o):e,f=Math.max(u[1][0]-u[0][0],u[1][1]-u[0][1]),s=t.__zoom,h="function"==typeof n?n.apply(t,o):n,d=l(s.invert(c).concat(f/s.k),h.invert(c).concat(f/h.k));return function(t){if(1===t)t=h;else{var n=d(t),e=f/n[2];t=new ww(e,c[0]-n[0]*e,c[1]-n[1]*e)}a.zoom(null,t)}}))}function w(t,n,e){return!e&&t.__zooming||new M(t,n)}function M(t,n){this.that=t,this.args=n,this.active=0,this.sourceEvent=null,this.extent=i.apply(t,n),this.taps=0}function T(t,...n){if(r.apply(this,arguments)){var e=w(this,n).event(t),i=this.__zoom,u=Math.max(c[0],Math.min(c[1],i.k*Math.pow(2,a.apply(this,arguments)))),s=ne(t);if(e.wheel)e.mouse[0][0]===s[0]&&e.mouse[0][1]===s[1]||(e.mouse[1]=i.invert(e.mouse[0]=s)),clearTimeout(e.wheel);else{if(i.k===u)return;e.mouse=[s,i.invert(s)],Gi(this),e.start()}Sw(t),e.wheel=setTimeout((function(){e.wheel=null,e.end()}),p),e.zoom("mouse",o(b(_(i,u),e.mouse[0],e.mouse[1]),e.extent,f))}}function A(t,...n){if(!e&&r.apply(this,arguments)){var i=t.currentTarget,a=w(this,n,!0).event(t),u=Zn(t.view).on("mousemove.zoom",(function(t){if(Sw(t),!a.moved){var n=t.clientX-s,e=t.clientY-l;a.moved=n*n+e*e>g}a.event(t).zoom("mouse",o(b(a.that.__zoom,a.mouse[0]=ne(t,i),a.mouse[1]),a.extent,f))}),!0).on("mouseup.zoom",(function(t){u.on("mousemove.zoom mouseup.zoom",null),ue(t.view,a.moved),Sw(t),a.event(t).end()}),!0),c=ne(t,i),s=t.clientX,l=t.clientY;ae(t.view),Aw(t),a.mouse=[c,this.__zoom.invert(c)],Gi(this),a.start()}}function S(t,...n){if(r.apply(this,arguments)){var e=this.__zoom,a=ne(t.changedTouches?t.changedTouches[0]:t,this),u=e.invert(a),c=e.k*(t.shiftKey?.5:2),l=o(b(_(e,c),a,u),i.apply(this,n),f);Sw(t),s>0?Zn(this).transition().duration(s).call(x,l,a,t):Zn(this).call(v.transform,l,a,t)}}function E(e,...i){if(r.apply(this,arguments)){var o,a,u,c,f=e.touches,s=f.length,l=w(this,i,e.changedTouches.length===s).event(e);for(Aw(e),a=0;a<s;++a)c=[c=ne(u=f[a],this),this.__zoom.invert(c),u.identifier],l.touch0?l.touch1||l.touch0[2]===c[2]||(l.touch1=c,l.taps=0):(l.touch0=c,o=!0,l.taps=1+!!t);t&&(t=clearTimeout(t)),o&&(l.taps<2&&(n=c[0],t=setTimeout((function(){t=null}),d)),Gi(this),l.start())}}function N(t,...n){if(this.__zooming){var e,r,i,a,u=w(this,n).event(t),c=t.changedTouches,s=c.length;for(Sw(t),e=0;e<s;++e)i=ne(r=c[e],this),u.touch0&&u.touch0[2]===r.identifier?u.touch0[0]=i:u.touch1&&u.touch1[2]===r.identifier&&(u.touch1[0]=i);if(r=u.that.__zoom,u.touch1){var l=u.touch0[0],h=u.touch0[1],d=u.touch1[0],p=u.touch1[1],g=(g=d[0]-l[0])*g+(g=d[1]-l[1])*g,y=(y=p[0]-h[0])*y+(y=p[1]-h[1])*y;r=_(r,Math.sqrt(g/y)),i=[(l[0]+d[0])/2,(l[1]+d[1])/2],a=[(h[0]+p[0])/2,(h[1]+p[1])/2]}else{if(!u.touch0)return;i=u.touch0[0],a=u.touch0[1]}u.zoom("touch",o(b(r,i,a),u.extent,f))}}function k(t,...r){if(this.__zooming){var i,o,a=w(this,r).event(t),u=t.changedTouches,c=u.length;for(Aw(t),e&&clearTimeout(e),e=setTimeout((function(){e=null}),d),i=0;i<c;++i)o=u[i],a.touch0&&a.touch0[2]===o.identifier?delete a.touch0:a.touch1&&a.touch1[2]===o.identifier&&delete a.touch1;if(a.touch1&&!a.touch0&&(a.touch0=a.touch1,delete a.touch1),a.touch0)a.touch0[1]=this.__zoom.invert(a.touch0[0]);else if(a.end(),2===a.taps&&(o=ne(o,this),Math.hypot(n[0]-o[0],n[1]-o[1])<y)){var f=Zn(this).on("dblclick.zoom");f&&f.apply(this,arguments)}}}return v.transform=function(t,n,e,r){var i=t.selection?t.selection():t;i.property("__zoom",kw),t!==i?x(t,n,e,r):i.interrupt().each((function(){w(this,arguments).event(r).start().zoom(null,"function"==typeof n?n.apply(this,arguments):n).end()}))},v.scaleBy=function(t,n,e,r){v.scaleTo(t,(function(){return this.__zoom.k*("function"==typeof n?n.apply(this,arguments):n)}),e,r)},v.scaleTo=function(t,n,e,r){v.transform(t,(function(){var t=i.apply(this,arguments),r=this.__zoom,a=null==e?m(t):"function"==typeof e?e.apply(this,arguments):e,u=r.invert(a),c="function"==typeof n?n.apply(this,arguments):n;return o(b(_(r,c),a,u),t,f)}),e,r)},v.translateBy=function(t,n,e,r){v.transform(t,(function(){return o(this.__zoom.translate("function"==typeof n?n.apply(this,arguments):n,"function"==typeof e?e.apply(this,arguments):e),i.apply(this,arguments),f)}),null,r)},v.translateTo=function(t,n,e,r,a){v.transform(t,(function(){var t=i.apply(this,arguments),a=this.__zoom,u=null==r?m(t):"function"==typeof r?r.apply(this,arguments):r;return o(Mw.translate(u[0],u[1]).scale(a.k).translate("function"==typeof n?-n.apply(this,arguments):-n,"function"==typeof e?-e.apply(this,arguments):-e),t,f)}),r,a)},M.prototype={event:function(t){return t&&(this.sourceEvent=t),this},start:function(){return 1==++this.active&&(this.that.__zooming=this,this.emit("start")),this},zoom:function(t,n){return this.mouse&&"mouse"!==t&&(this.mouse[1]=n.invert(this.mouse[0])),this.touch0&&"touch"!==t&&(this.touch0[1]=n.invert(this.touch0[0])),this.touch1&&"touch"!==t&&(this.touch1[1]=n.invert(this.touch1[0])),this.that.__zoom=n,this.emit("zoom"),this},end:function(){return 0==--this.active&&(delete this.that.__zooming,this.emit("end")),this},emit:function(t){var n=Zn(this.that).datum();h.call(t,this.that,new xw(t,{sourceEvent:this.sourceEvent,target:v,type:t,transform:this.that.__zoom,dispatch:h}),n)}},v.wheelDelta=function(t){return arguments.length?(a="function"==typeof t?t:mw(+t),v):a},v.filter=function(t){return arguments.length?(r="function"==typeof t?t:mw(!!t),v):r},v.touchable=function(t){return arguments.length?(u="function"==typeof t?t:mw(!!t),v):u},v.extent=function(t){return arguments.length?(i="function"==typeof t?t:mw([[+t[0][0],+t[0][1]],[+t[1][0],+t[1][1]]]),v):i},v.scaleExtent=function(t){return arguments.length?(c[0]=+t[0],c[1]=+t[1],v):[c[0],c[1]]},v.translateExtent=function(t){return arguments.length?(f[0][0]=+t[0][0],f[1][0]=+t[1][0],f[0][1]=+t[0][1],f[1][1]=+t[1][1],v):[[f[0][0],f[0][1]],[f[1][0],f[1][1]]]},v.constrain=function(t){return arguments.length?(o=t,v):o},v.duration=function(t){return arguments.length?(s=+t,v):s},v.interpolate=function(t){return arguments.length?(l=t,v):l},v.on=function(){var t=h.on.apply(h,arguments);return t===h?v:t},v.clickDistance=function(t){return arguments.length?(g=(t=+t)*t,v):Math.sqrt(g)},v.tapDistance=function(t){return arguments.length?(y=+t,v):y},v},t.zoomIdentity=Mw,t.zoomTransform=Tw}));
diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 6b15004..988d2eb 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -14,6 +14,7 @@
 from common.run_events import _to_plain
 
 _MAX_SUMMARY_CARDS = 7
+_D3_ASSET = Path(__file__).resolve().parent / "assets" / "d3.v7.min.js"
 
 
 def write_command_report(
@@ -378,6 +379,20 @@ def _render_page(
 .focus-card-meta {{ color:var(--muted); font-size:13px; overflow-wrap:anywhere; word-break:break-word; }}
 .focus-links {{ display:flex; flex-wrap:wrap; gap:6px; }}
 .focus-link {{ border:1px solid var(--line); border-radius:999px; padding:2px 8px; background:#fff; font-size:12px; }}
+.focused-graph-section {{ overflow-x:hidden; }}
+.focused-graph-toolbar {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; }}
+.focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid var(--line); border-radius:8px; background:#fff; color:var(--text); padding:6px 10px; font:inherit; }}
+.focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); }}
+.focused-graph-stage {{ border:1px solid var(--line); border-radius:12px; background:#fbfdff; min-height:480px; position:relative; overflow:hidden; }}
+.focused-graph-svg {{ display:block; width:100%; height:480px; }}
+.focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed var(--line); border-radius:10px; background:#fff; color:var(--muted); }}
+.focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; }}
+.legend-item {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); font-size:13px; }}
+.legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid var(--line); }}
+.legend-semantic {{ background:#2563eb; }}
+.legend-code {{ background:#16a34a; }}
+.legend-mapping {{ background:#f59e0b; }}
+.legend-context {{ background:#64748b; }}
 @media (max-width:720px) {{ main {{ padding:22px 12px 36px; }} .focus-map {{ grid-template-columns:1fr; }} table {{ min-width:560px; }} }}
 </style>
 </head>
@@ -390,8 +405,7 @@ def _render_page(
 {_render_summary_cards(summary_cards)}
 {_render_timeline(stages)}
 {_render_safety_boundary(user_decisions)}
-{_render_focused_nodes_map(focused_view, code_file_anchors)}
-{_render_semantic_code_impact_chain(retrievals, rpg_nodes, dep_nodes, focused_view, code_file_anchors)}
+{_render_focused_graph(focused_view, code_file_anchors)}
 {_render_code_deltas(code_deltas, code_delta_anchors)}
 {_render_verification(verification)}
 {_render_artifacts(artifacts)}
@@ -843,7 +857,319 @@ def _nodes_view_edges_html(edges: Sequence[Mapping[str, Any]]) -> str:
     )
 
 
-def _render_focused_nodes_map(focused_view: dict[str, Any], file_anchors: Mapping[str, str]) -> str:
+def _inline_d3() -> str:
+    try:
+        return _D3_ASSET.read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def _json_for_script(value: Any) -> str:
+    data = json.dumps(value, ensure_ascii=False, default=_json_default)
+    return (
+        data.replace("&", "\\u0026")
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("
", "\\u2028")
+        .replace("
", "\\u2029")
+    )
+
+
+def _graph_label(row: Mapping[str, Any], fallback: Any) -> str:
+    for key in ("name", "symbol", "label", "path", "node_id", "dep_node_id", "id"):
+        value = row.get(key)
+        if value not in (None, ""):
+            return str(value)
+    return str(fallback or "node")
+
+
+def _graph_diff_ref(row: Mapping[str, Any], file_anchors: Mapping[str, str]) -> dict[str, str]:
+    refs = _as_sequence(row.get("changed_files"))
+    path = row.get("path") or row.get("file") or row.get("module")
+    if not refs and row.get("diff_anchor") and path not in (None, ""):
+        refs = [{"path": path, "diff_anchor": row.get("diff_anchor")}]
+    for ref in refs:
+        if isinstance(ref, Mapping):
+            ref_path = ref.get("path") or ref.get("file")
+            anchor = ref.get("diff_anchor") or file_anchors.get(str(ref_path or ""))
+        else:
+            ref_path = ref
+            anchor = file_anchors.get(str(ref_path or ""))
+        if ref_path not in (None, "") and anchor:
+            return {"path": str(ref_path), "href": f"#{anchor}"}
+    return {}
+
+
+def _graph_node_id(row: Mapping[str, Any], kind: str) -> str:
+    explicit = _node_view_id(row)
+    if explicit:
+        return explicit
+    if kind == "mapping":
+        node_id = f"{row.get('rpg_node_id') or 'semantic'}-{row.get('code_node_id') or row.get('dep_node_id') or 'missing'}"
+    else:
+        node_id = row.get("node_id") or row.get("dep_node_id") or row.get("id") or kind
+    return f"{kind}-{_slug(str(node_id))}"
+
+
+def _append_graph_node(nodes: list[dict[str, Any]], seen: set[str], row: Mapping[str, Any], kind: str, file_anchors: Mapping[str, str]) -> str:
+    node_id = _graph_node_id(row, kind)
+    if node_id in seen:
+        return node_id
+    seen.add(node_id)
+    payload: dict[str, Any] = {
+        "id": node_id,
+        "kind": kind,
+        "label": _graph_label(row, row.get("node_id") or row.get("dep_node_id") or node_id),
+        "node_id": row.get("node_id") or row.get("dep_node_id"),
+        "state": row.get("state") or row.get("status") or row.get("mapping_status"),
+    }
+    for key in ("path", "type", "node_type", "source", "mapping_status", "locate_status", "breadcrumb_path"):
+        if row.get(key) not in (None, ""):
+            payload[key] = row.get(key)
+    diff_ref = _graph_diff_ref(row, file_anchors)
+    if diff_ref:
+        payload["diff"] = diff_ref
+    nodes.append(payload)
+    return node_id
+
+
+def _append_context_node(nodes: list[dict[str, Any]], seen: set[str], link_id: Any, node_id: Any) -> str:
+    graph_id = str(link_id or f"context-{_slug(str(node_id or 'node'))}")
+    if graph_id not in seen:
+        seen.add(graph_id)
+        nodes.append({"id": graph_id, "kind": "context", "label": str(node_id or "context"), "node_id": node_id, "state": "context"})
+    return graph_id
+
+
+def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mapping[str, str]) -> dict[str, Any]:
+    nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
+    summary = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else focused_view.get("summary", {})
+    semantic_nodes = [node for node in _as_sequence(nodes_view.get("semantic_nodes")) if isinstance(node, Mapping)]
+    code_nodes = [node for node in _as_sequence(nodes_view.get("code_nodes")) if isinstance(node, Mapping)]
+    mappings = [mapping for mapping in _as_sequence(nodes_view.get("mappings")) if isinstance(mapping, Mapping)]
+    context_edges = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
+    hidden_counts = nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else focused_view.get("hidden_counts", {})
+    warnings = [warning for warning in _as_sequence(nodes_view.get("warnings")) if isinstance(warning, Mapping)]
+    nodes: list[dict[str, Any]] = []
+    seen_nodes: set[str] = set()
+    rpg_links: dict[str, str] = {}
+    code_links: dict[str, str] = {}
+
+    for node in semantic_nodes:
+        link_id = _append_graph_node(nodes, seen_nodes, node, "semantic", file_anchors)
+        node_id = node.get("node_id")
+        if node_id not in (None, ""):
+            rpg_links[str(node_id)] = link_id
+    for node in code_nodes:
+        link_id = _append_graph_node(nodes, seen_nodes, node, "code", file_anchors)
+        node_id = node.get("node_id") or node.get("dep_node_id")
+        if node_id not in (None, ""):
+            code_links[str(node_id)] = link_id
+
+    links: list[dict[str, Any]] = []
+    for mapping in mappings:
+        mapping_id = _append_graph_node(nodes, seen_nodes, mapping, "mapping", file_anchors)
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        source = mapping.get("source_link_id") or rpg_links.get(str(rpg_id or ""))
+        target = mapping.get("target_link_id") or code_links.get(str(code_id or ""))
+        if source:
+            links.append({"id": f"{mapping_id}-semantic", "source": source, "target": mapping_id, "kind": "mapping", "relation": mapping.get("status") or "mapped"})
+        if target:
+            links.append({"id": f"{mapping_id}-code", "source": mapping_id, "target": target, "kind": "mapping", "relation": mapping.get("source") or "code"})
+
+    for edge in context_edges:
+        source = edge.get("source_link_id")
+        target = edge.get("target_link_id")
+        if not source:
+            source = _append_context_node(nodes, seen_nodes, None, edge.get("source_node_id"))
+        elif str(source) not in seen_nodes:
+            _append_context_node(nodes, seen_nodes, source, edge.get("source_node_id"))
+        if not target:
+            target = _append_context_node(nodes, seen_nodes, None, edge.get("target_node_id"))
+        elif str(target) not in seen_nodes:
+            _append_context_node(nodes, seen_nodes, target, edge.get("target_node_id"))
+        links.append({
+            "id": edge.get("link_id") or f"edge-{len(links) + 1}",
+            "source": str(source),
+            "target": str(target),
+            "kind": "context",
+            "relation": edge.get("relation") or "dependency",
+            "direction": edge.get("direction"),
+        })
+
+    focused_graph = nodes_view.get("focused_graph") if isinstance(nodes_view.get("focused_graph"), Mapping) else {}
+    hierarchy = nodes_view.get("hierarchy") or focused_graph.get("hierarchy") or {}
+    default_focus = nodes_view.get("default_focus") or focused_graph.get("default_focus") or {}
+    return {
+        "schema": "cmind.focused_graph.render.v1",
+        "summary": summary,
+        "nodes": nodes,
+        "links": links,
+        "semantic_nodes": semantic_nodes,
+        "code_nodes": code_nodes,
+        "mappings": mappings,
+        "edges": context_edges,
+        "hidden_counts": hidden_counts,
+        "warnings": warnings,
+        "hierarchy": hierarchy,
+        "default_focus": default_focus,
+    }
+
+
+def _focused_graph_evidence(nodes_view: Mapping[str, Any], file_anchors: Mapping[str, str]) -> str:
+    semantic_cards = [
+        _semantic_card(node, file_anchors)
+        for node in _as_sequence(nodes_view.get("semantic_nodes"))
+        if isinstance(node, Mapping)
+    ]
+    code_cards = [
+        _code_card(node, file_anchors)
+        for node in _as_sequence(nodes_view.get("code_nodes"))
+        if isinstance(node, Mapping)
+    ]
+    mapping_cards = [
+        _mapping_card(mapping)
+        for mapping in _as_sequence(nodes_view.get("mappings"))
+        if isinstance(mapping, Mapping)
+    ]
+    edge_rows = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
+    body = "<h3>Focused graph evidence</h3>"
+    if semantic_cards or code_cards or mapping_cards:
+        body += '<div class="focus-map">' + "".join(semantic_cards + code_cards + mapping_cards) + "</div>"
+    else:
+        body += '<p class="empty">No focused graph evidence rows recorded.</p>'
+    body += _nodes_view_edges_html(edge_rows)
+    return body
+
+
+def _focused_graph_runtime() -> str:
+    return r"""
+(function(){
+  const section = document.currentScript.closest('[data-focused-graph]');
+  if (!section) return;
+  const dataEl = section.querySelector('[data-focused-graph-json]');
+  const svg = section.querySelector('[data-focused-graph-svg]');
+  const fallback = section.querySelector('[data-focused-graph-fallback]');
+  if (!window.d3 || !dataEl || !svg) return;
+  if (fallback) fallback.hidden = true;
+  const data = JSON.parse(dataEl.textContent || '{}');
+  const ns = 'http://www.w3.org/2000/svg';
+  let scale = 1;
+  let showEdges = true;
+  let query = '';
+  function make(tag, attrs, text) {
+    const el = document.createElementNS(ns, tag);
+    Object.entries(attrs || {}).forEach(([key, value]) => el.setAttribute(key, value));
+    if (text !== undefined) el.textContent = text;
+    return el;
+  }
+  function fill(kind) {
+    return kind === 'semantic' ? '#2563eb' : kind === 'code' ? '#16a34a' : kind === 'mapping' ? '#f59e0b' : '#64748b';
+  }
+  function layout(nodes) {
+    const groups = {semantic: [], mapping: [], code: [], context: []};
+    nodes.forEach(node => (groups[node.kind] || groups.context).push(node));
+    const x = {semantic: 150, mapping: 420, code: 690, context: 840};
+    Object.entries(groups).forEach(([kind, rows]) => {
+      const gap = Math.max(44, Math.min(78, 380 / Math.max(rows.length, 1)));
+      const start = 240 - ((rows.length - 1) * gap) / 2;
+      rows.forEach((node, index) => { node.x = x[kind] || 500; node.y = start + index * gap; });
+    });
+  }
+  function render() {
+    const nodes = (data.nodes || []).map(node => ({...node}));
+    const byId = new Map(nodes.map(node => [node.id, node]));
+    layout(nodes);
+    while (svg.firstChild) svg.removeChild(svg.firstChild);
+    svg.setAttribute('viewBox', `0 0 ${960 / scale} ${480 / scale}`);
+    const links = data.links || [];
+    if (showEdges) {
+      links.forEach(link => {
+        const source = byId.get(link.source), target = byId.get(link.target);
+        if (!source || !target) return;
+        const line = make('line', {x1: source.x, y1: source.y, x2: target.x, y2: target.y, stroke: link.kind === 'mapping' ? '#f59e0b' : '#94a3b8', 'stroke-width': link.kind === 'mapping' ? 2 : 1.4, opacity: .78});
+        svg.appendChild(line);
+      });
+    }
+    nodes.forEach(node => {
+      const matches = !query || `${node.label} ${node.node_id || ''} ${node.path || ''}`.toLowerCase().includes(query);
+      const group = make('g', {transform: `translate(${node.x},${node.y})`, opacity: matches ? '1' : '.18'});
+      group.appendChild(make('circle', {r: node.kind === 'mapping' ? 6 : 8, fill: fill(node.kind), stroke: '#fff', 'stroke-width': 2}));
+      group.appendChild(make('text', {x: 13, y: 4, 'font-size': 12, fill: '#1f2937'}, (node.label || node.id || '').slice(0, 42)));
+      group.appendChild(make('title', {}, `${node.kind}: ${node.label || node.id}`));
+      svg.appendChild(group);
+    });
+  }
+  section.querySelector('[data-action="reset"]')?.addEventListener('click', () => { scale = 1; query = ''; showEdges = true; const search = section.querySelector('[data-action="search"]'); if (search) search.value = ''; const edges = section.querySelector('[data-action="edges"]'); if (edges) edges.checked = true; render(); });
+  section.querySelector('[data-action="depth-plus"]')?.addEventListener('click', () => { scale = Math.min(1.8, scale + .15); render(); });
+  section.querySelector('[data-action="depth-minus"]')?.addEventListener('click', () => { scale = Math.max(.7, scale - .15); render(); });
+  section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; render(); });
+  section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = event.target.value.toLowerCase(); render(); });
+  render();
+})();
+"""
+
+
+def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[str, str]) -> str:
+    nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
+    if not focused_view and not nodes_view:
+        return ""
+    summary = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else focused_view.get("summary", {})
+    summary_html = _summary_badges(summary, [
+        ("Semantic nodes", "semantic_nodes", len(_as_sequence(nodes_view.get("semantic_nodes")))),
+        ("Code nodes", "code_nodes", len(_as_sequence(nodes_view.get("code_nodes")))),
+        ("Mappings", "mappings", len(_as_sequence(nodes_view.get("mappings")))),
+        ("Edges", "edges", len(_as_sequence(nodes_view.get("edges")))),
+        ("Warnings", "warnings", len(_as_sequence(nodes_view.get("warnings")))),
+    ])
+    hidden_counts = nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else focused_view.get("hidden_counts", {})
+    hidden_html = _hidden_context_html(hidden_counts if isinstance(hidden_counts, Mapping) else {})
+    warnings = [warning for warning in _as_sequence(nodes_view.get("warnings") or focused_view.get("warnings")) if isinstance(warning, Mapping)]
+    warnings_html = f"<h3>Warnings</h3>{_chain_warning_html(warnings)}" if warnings else ""
+    graph_payload = _focused_graph_payload(focused_view, file_anchors)
+    graph_json = _json_for_script(graph_payload)
+    d3_js = _inline_d3()
+    fallback_hidden = " hidden" if d3_js else ""
+    d3_missing_note = "" if d3_js else '<p class="reason">Local D3 asset missing; showing the static fallback.</p>'
+    scripts = ""
+    if d3_js:
+        scripts = f"<script>{d3_js}</script><script>{_focused_graph_runtime()}</script>"
+    inspector_payload = {"focused_graph": graph_payload, "nodes_view": nodes_view}
+    inspector = json.dumps(inspector_payload, indent=2, ensure_ascii=False, default=_json_default)
+    controls = (
+        '<div class="focused-graph-toolbar">'
+        '<button type="button" data-action="reset">Reset</button>'
+        '<button type="button" data-action="depth-plus">+1</button>'
+        '<button type="button" data-action="depth-minus">-1</button>'
+        '<label><input type="checkbox" data-action="edges" checked> Edges</label>'
+        '<input type="search" data-action="search" placeholder="Search nodes" aria-label="Search focused graph nodes">'
+        '</div>'
+    )
+    legend = (
+        '<div class="focused-graph-legend" aria-label="Focused graph legend">'
+        '<span class="legend-item"><span class="legend-swatch legend-semantic"></span>Semantic</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-code"></span>Code</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-mapping"></span>Mapping</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-context"></span>Context edge</span>'
+        '</div>'
+    )
+    return (
+        '<section class="focused-graph-section" data-focused-graph><h2>Focused graph</h2>'
+        f"{summary_html}{controls}{legend}{warnings_html}{hidden_html}"
+        f"<script type=\"application/json\" data-focused-graph-json>{graph_json}</script>"
+        '<div class="focused-graph-stage">'
+        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="480"></svg>'
+        f'<div class="focused-graph-fallback" data-focused-graph-fallback{fallback_hidden}>Static focused graph fallback is available when D3 cannot run.{d3_missing_note}</div>'
+        '</div>'
+        f"{_focused_graph_evidence(nodes_view, file_anchors)}"
+        f"<details><summary>Inspector JSON</summary><pre>{_h(inspector)}</pre></details>"
+        f"{scripts}"
+        '</section>'
+    )
+
+
+def _legacy_render_focused_nodes_map(focused_view: dict[str, Any], file_anchors: Mapping[str, str]) -> str:
     nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
     if not nodes_view:
         return ""
@@ -1046,7 +1372,7 @@ def _render_legacy_chain_rows(
     return "".join(blocks)
 
 
-def _render_semantic_code_impact_chain(
+def _legacy_render_semantic_code_impact_chain(
     retrievals: list[dict[str, Any]],
     rpg_nodes: list[dict[str, Any]],
     dep_nodes: list[dict[str, Any]],
@@ -1149,7 +1475,7 @@ def _compact_payload(value: Any, *, depth: int = 0) -> Any:
         compacted: dict[str, Any] = {}
         for key, item in value.items():
             key_text = str(key)
-            if key_text in {"code_deltas", "focused_view", "focused_impact", "focused_graph", "evidence"}:
+            if key_text in {"code_deltas", "focused_view", "nodes_view", "focused_impact", "focused_graph", "evidence"}:
                 continue
             if key_text == "diff":
                 compacted["has_diff"] = bool(item)
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 2da1859..e6fa182 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -432,6 +432,196 @@ def _warning_link_fields(warning: Dict[str, Any], rpg_nodes: Dict[str, Dict[str,
     return row
 
 
+def _hierarchy_segments(value: Any) -> List[str]:
+    if isinstance(value, (list, tuple)):
+        return [str(item) for item in value if item not in (None, "")]
+    if value in (None, ""):
+        return []
+    text = str(value)
+    separator = " / " if " / " in text else "/"
+    return [part.strip() for part in text.split(separator) if part.strip()]
+
+
+def _hierarchy_child(parent: Dict[str, Any], child_id: str, name: str, kind: str) -> Dict[str, Any]:
+    children = parent.setdefault("children", [])
+    for child in children:
+        if isinstance(child, dict) and child.get("id") == child_id:
+            return child
+    child = {"id": child_id, "name": name, "kind": kind, "children": []}
+    children.append(child)
+    return child
+
+
+def _append_hierarchy_leaf(parent: Dict[str, Any], leaf: Dict[str, Any]) -> None:
+    children = parent.setdefault("children", [])
+    leaf_id = leaf.get("id")
+    if any(isinstance(child, dict) and child.get("id") == leaf_id for child in children):
+        return
+    children.append(leaf)
+
+
+def _add_hierarchy_path(root: Dict[str, Any], parts: List[str], leaf: Dict[str, Any], group_kind: str) -> None:
+    parent = root
+    trail: List[str] = []
+    for part in parts:
+        trail.append(part)
+        parent = _hierarchy_child(parent, _node_link_id(group_kind, "/".join(trail)), part, group_kind)
+    _append_hierarchy_leaf(parent, leaf)
+
+
+def _semantic_hierarchy_parts(node: Dict[str, Any]) -> List[str]:
+    for key in ("breadcrumb", "breadcrumb_path", "feature_path", "path"):
+        parts = _hierarchy_segments(node.get(key))
+        if parts:
+            return parts[:-1] if len(parts) > 1 else []
+    return []
+
+
+def _code_hierarchy_parts(node: Dict[str, Any]) -> List[str]:
+    for key in ("path", "module", "file"):
+        parts = _hierarchy_segments(node.get(key))
+        if parts:
+            return parts[:-1]
+    return []
+
+
+def _focused_graph_hierarchy(
+    semantic_nodes: List[Dict[str, Any]],
+    code_nodes: List[Dict[str, Any]],
+    mappings: List[Dict[str, Any]],
+    edges: List[Dict[str, Any]],
+    hidden_counts: Dict[str, Any],
+    warnings: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    root: Dict[str, Any] = {
+        "id": "focused-graph-root",
+        "name": "Focused graph",
+        "kind": "root",
+        "meta": {"hidden_counts": hidden_counts, "warnings": len(warnings), "edges": len(edges)},
+        "children": [],
+    }
+    semantic_root = _hierarchy_child(root, "focused-semantic-root", "Semantic scope", "semantic_group")
+    code_root = _hierarchy_child(root, "focused-code-root", "Code scope", "code_group")
+    mapping_root = _hierarchy_child(root, "focused-mapping-root", "Mappings", "mapping_group")
+    context_root = _hierarchy_child(root, "focused-context-root", "One-hop context", "context_group")
+
+    known_link_ids: set[str] = set()
+    for node in semantic_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        known_link_ids.add(link_id)
+        leaf = {
+            "id": link_id,
+            "node_id": node.get("node_id"),
+            "name": node.get("name") or node.get("symbol") or node.get("node_id") or "semantic node",
+            "kind": "semantic",
+            "state": node.get("state"),
+            "mapping_status": node.get("mapping_status"),
+        }
+        _add_hierarchy_path(semantic_root, _semantic_hierarchy_parts(node), leaf, "semantic-path")
+
+    for node in code_nodes:
+        code_id = node.get("node_id") or node.get("dep_node_id")
+        link_id = str(node.get("link_id") or _node_link_id("code", code_id))
+        known_link_ids.add(link_id)
+        leaf = {
+            "id": link_id,
+            "node_id": code_id,
+            "name": node.get("symbol") or node.get("name") or code_id or "code node",
+            "kind": "code",
+            "state": node.get("state"),
+            "path": node.get("path"),
+        }
+        _add_hierarchy_path(code_root, _code_hierarchy_parts(node), leaf, "code-path")
+
+    for mapping in mappings:
+        link_id = str(mapping.get("link_id") or _node_link_id("map", f"{mapping.get('rpg_node_id')}-{mapping.get('code_node_id') or 'missing'}"))
+        known_link_ids.add(link_id)
+        target = mapping.get("code_node_id") or mapping.get("dep_node_id") or "missing mapping"
+        _append_hierarchy_leaf(mapping_root, {
+            "id": link_id,
+            "name": f"{mapping.get('rpg_node_id')} → {target}",
+            "kind": "mapping",
+            "state": mapping.get("state") or mapping.get("status"),
+            "rpg_node_id": mapping.get("rpg_node_id"),
+            "code_node_id": mapping.get("code_node_id") or mapping.get("dep_node_id"),
+        })
+
+    context_link_ids: set[str] = set()
+    for edge in edges:
+        for endpoint_key, link_key in (("source_node_id", "source_link_id"), ("target_node_id", "target_link_id")):
+            link_id = edge.get(link_key)
+            node_id = edge.get(endpoint_key)
+            if link_id in (None, "") or str(link_id) in known_link_ids or str(link_id) in context_link_ids:
+                continue
+            context_link_ids.add(str(link_id))
+            _append_hierarchy_leaf(context_root, {
+                "id": str(link_id),
+                "node_id": node_id,
+                "name": node_id or "context node",
+                "kind": "context",
+            })
+    return root
+
+
+def _focused_graph_default_focus(
+    semantic_nodes: List[Dict[str, Any]],
+    code_nodes: List[Dict[str, Any]],
+    mappings: List[Dict[str, Any]],
+    edges: List[Dict[str, Any]],
+    warnings: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    semantic_links = [str(node.get("link_id") or _node_link_id("rpg", node.get("node_id"))) for node in semantic_nodes]
+    code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
+    changed_code_links = [
+        str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        for node in code_nodes
+        if node.get("changed") or node.get("changed_files") or node.get("diff_anchor")
+    ]
+    warning_links = []
+    for warning in warnings:
+        warning_links.extend(_listify(warning.get("node_link_id")) + _listify(warning.get("code_link_id")))
+    node_link_ids = _ordered_unique(semantic_links + changed_code_links + warning_links)
+    if not node_link_ids:
+        node_link_ids = _ordered_unique(semantic_links + code_links)
+    return {
+        "node_link_ids": node_link_ids,
+        "semantic_node_ids": _ordered_unique([node.get("node_id") for node in semantic_nodes]),
+        "code_node_ids": _ordered_unique([node.get("node_id") or node.get("dep_node_id") for node in code_nodes]),
+        "mapping_link_ids": _ordered_unique([mapping.get("link_id") for mapping in mappings]),
+        "edge_link_ids": _ordered_unique([edge.get("link_id") for edge in edges]),
+        "edge_depth": 1,
+        "show_edges": True,
+    }
+
+
+def _focused_graph_metadata(
+    semantic_nodes: List[Dict[str, Any]],
+    code_nodes: List[Dict[str, Any]],
+    mappings: List[Dict[str, Any]],
+    edges: List[Dict[str, Any]],
+    hidden_counts: Dict[str, Any],
+    warnings: List[Dict[str, Any]],
+    caps: Optional[Dict[str, Any]],
+    graph_context: Optional[Dict[str, Any]],
+) -> Dict[str, Any]:
+    hierarchy = _focused_graph_hierarchy(semantic_nodes, code_nodes, mappings, edges, hidden_counts, warnings)
+    default_focus = _focused_graph_default_focus(semantic_nodes, code_nodes, mappings, edges, warnings)
+    focused_graph: Dict[str, Any] = {
+        "schema": "cmind.focused_graph.v1",
+        "hierarchy": hierarchy,
+        "default_focus": default_focus,
+    }
+    if caps:
+        focused_graph["caps"] = caps
+    if graph_context:
+        focused_graph["graph_context"] = graph_context
+    if hidden_counts:
+        focused_graph["hidden_counts"] = hidden_counts
+    if warnings:
+        focused_graph["warning_count"] = len(warnings)
+    return focused_graph
+
+
 def _build_nodes_view(
     primary_rpg_nodes: List[Dict[str, Any]],
     primary_code_nodes: List[Dict[str, Any]],
@@ -441,6 +631,9 @@ def _build_nodes_view(
     warnings: List[Dict[str, Any]],
     changed_files: List[str],
     diff_anchors: Dict[str, str],
+    *,
+    caps: Optional[Dict[str, Any]] = None,
+    graph_context: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     rpg_by_id = {str(row.get("node_id")): row for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
     code_by_id = {str(row.get("node_id") or row.get("dep_node_id")): row for row in primary_code_nodes if (row.get("node_id") or row.get("dep_node_id")) not in (None, "")}
@@ -543,12 +736,14 @@ def _build_nodes_view(
     for edge in edges:
         source_id = edge.get("source_node_id")
         target_id = edge.get("target_node_id")
+        relation = edge.get("relation") or "dependency"
         row: Dict[str, Any] = {
+            "link_id": _node_link_id("edge", f"{source_id}-{relation}-{target_id}"),
             "source_node_id": source_id,
             "target_node_id": target_id,
             "source_link_id": _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
             "target_link_id": _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
-            "relation": edge.get("relation") or "dependency",
+            "relation": relation,
             "state": edge.get("status") or "visible",
         }
         for key in ("direction", "source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
@@ -556,6 +751,16 @@ def _build_nodes_view(
         edge_rows.append(row)
 
     warning_rows = [_warning_link_fields(warning, rpg_by_id, code_by_id) for warning in warnings if isinstance(warning, dict)]
+    focused_graph = _focused_graph_metadata(
+        semantic_nodes,
+        code_nodes,
+        mapping_rows,
+        edge_rows,
+        hidden_counts,
+        warning_rows,
+        caps or {},
+        graph_context or {},
+    )
     return {
         "summary": {
             "semantic_nodes": len(semantic_nodes),
@@ -572,6 +777,11 @@ def _build_nodes_view(
         "hidden_counts": hidden_counts,
         "warnings": warning_rows,
         "changed_files": _changed_file_refs(changed_files, diff_anchors),
+        "hierarchy": focused_graph["hierarchy"],
+        "default_focus": focused_graph["default_focus"],
+        "focused_graph": focused_graph,
+        "caps": caps or {},
+        "graph_context": graph_context or {},
     }
 
 
@@ -1097,7 +1307,29 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
     mapped_code_relations = sum(1 for row in mapping_rows_all if row.get("code_node_id"))
     missing_mappings = sum(1 for row in mapping_rows_all if row.get("status") == "missing")
     diff_anchors = _diff_anchor_map(code_deltas)
-    nodes_view = _build_nodes_view(primary_rpg_nodes, primary_code_nodes, mappings, edges, hidden_counts, warnings, changed_files, diff_anchors)
+    focused_caps = {
+        "primary_rpg_nodes": _FOCUSED_RPG_NODE_CAP,
+        "primary_code_nodes": _FOCUSED_CODE_NODE_CAP,
+        "edges": _FOCUSED_EDGE_CAP,
+    }
+    graph_context = {
+        "current_graph_available": current_graph_available,
+        "current_rpg_nodes": len(current_rpg_nodes),
+        "current_dep_nodes": len(current_dep_nodes),
+        "current_dep_edges": len(current_dep_edges),
+    }
+    nodes_view = _build_nodes_view(
+        primary_rpg_nodes,
+        primary_code_nodes,
+        mappings,
+        edges,
+        hidden_counts,
+        warnings,
+        changed_files,
+        diff_anchors,
+        caps=focused_caps,
+        graph_context=graph_context,
+    )
     summary = {
         "selected_feature_groups": len(primary_rpg_nodes_all),
         "primary_rpg_nodes": len(primary_rpg_nodes),
@@ -1126,11 +1358,7 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         "warnings": warnings,
         "changed_files": changed_files,
         "unmatched_code_deltas": unmatched_code_deltas,
-        "caps": {
-            "primary_rpg_nodes": _FOCUSED_RPG_NODE_CAP,
-            "primary_code_nodes": _FOCUSED_CODE_NODE_CAP,
-            "edges": _FOCUSED_EDGE_CAP,
-        },
+        "caps": focused_caps,
         "apply": {
             "status": _apply_status(apply_result),
             "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 82018d9..020587b 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -279,7 +279,10 @@ def fake_write_command_report(run):
         assert "review_result" not in evidence
         assert "focused_view" not in evidence
         assert "nodes_view" not in evidence_text
+        assert "default_focus" not in evidence_text
+        assert "hierarchy" not in evidence_text
         assert "focused_graph" not in evidence
+        assert "focused_graph" not in evidence_text
         assert "focused_impact" not in evidence
         assert "+new <unsafe>" not in evidence_text
         evidence_paths = {item["label"]: item["path"] for item in evidence["artifact_paths"]}
@@ -346,6 +349,18 @@ def fake_write_command_report(run):
         assert bridge_by_rpg["n2"]["state"] == "missing_mapping"
         assert nodes_view["hidden_counts"]["callers"] == 1
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in nodes_view["warnings"])
+        assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
+        assert nodes_view["default_focus"]["node_link_ids"]
+        assert "rpg-n1" in nodes_view["default_focus"]["node_link_ids"]
+        assert nodes_view["default_focus"]["edge_depth"] == 1
+        assert nodes_view["default_focus"]["show_edges"] is True
+        assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
+        assert nodes_view["focused_graph"]["hierarchy"]["id"] == "focused-graph-root"
+        assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]
+        assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
+        assert nodes_view["graph_context"]["current_graph_available"] is True
+        assert nodes_view["graph_context"]["current_rpg_nodes"] == 2
+        assert nodes_view["graph_context"]["current_dep_nodes"] == 1
         assert "+new <unsafe>" not in json.dumps(nodes_view, ensure_ascii=False)
         return report_path
 
@@ -477,7 +492,10 @@ def fake_write_command_report(run):
         assert "review_result" not in evidence
         assert "focused_view" not in evidence
         assert "nodes_view" not in evidence_text
+        assert "default_focus" not in evidence_text
+        assert "hierarchy" not in evidence_text
         assert "focused_graph" not in evidence
+        assert "focused_graph" not in evidence_text
         assert "focused_impact" not in evidence
         assert "failing test" not in evidence_text
         evidence_paths = {item["label"]: item["path"] for item in evidence["artifact_paths"]}
@@ -530,6 +548,15 @@ def fake_write_command_report(run):
         assert bridge["status"] == "mapped"
         assert bridge["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
         assert any(row["type"] == "missing_reason" and row["node_id"] == "planned" for row in nodes_view["warnings"])
+        assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
+        assert nodes_view["default_focus"]["node_link_ids"] == ["rpg-planned", "code-scripts-common-run_report.py-_render_artifacts"]
+        assert nodes_view["default_focus"]["edge_depth"] == 1
+        assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
+        assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]
+        assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
+        assert nodes_view["graph_context"]["current_graph_available"] is True
+        assert nodes_view["graph_context"]["current_rpg_nodes"] == 1
+        assert nodes_view["graph_context"]["current_dep_nodes"] == 1
         assert focused["apply"]["status"] == "dep_refreshed"
         return report_path
 
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index d5e4da4..820034d 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -24,8 +24,10 @@
 
 
 def test_run_report_exposes_current_impact_renderers_only() -> None:
-    assert hasattr(run_report, "_render_semantic_code_impact_chain")
-    assert hasattr(run_report, "_render_focused_nodes_map")
+    assert hasattr(run_report, "_render_focused_graph")
+    assert hasattr(run_report, "_inline_d3")
+    assert not hasattr(run_report, "_render_semantic_code_impact_chain")
+    assert not hasattr(run_report, "_render_focused_nodes_map")
     assert not hasattr(run_report, "_render_why_these_nodes")
     assert not hasattr(run_report, "_render_node_rows")
     assert not hasattr(run_report, "_render_focused_impact")
@@ -71,8 +73,7 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
         "Summary",
         "Stage timeline",
         "Safety boundary",
-        "Focused nodes map",
-        "semantic-code impact chain",
+        "Focused graph",
         "What changed?",
         "Verification status",
         "Artifact links",
@@ -229,6 +230,25 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
                         {"type": "stale_graph", "message": "Stale <graph>", "dep_node_id": "old.py:f"},
                     ],
                     "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
+                    "hierarchy": {
+                        "id": "focused-graph-root",
+                        "name": "Focused graph",
+                        "kind": "root",
+                        "children": [
+                            {"id": "rpg-n1-script", "name": "Node <unsafe>", "kind": "semantic"},
+                            {"id": "code-a.py-f-script", "name": "func <unsafe>", "kind": "code"},
+                        ],
+                    },
+                    "default_focus": {
+                        "node_link_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                        "edge_depth": 1,
+                        "show_edges": True,
+                    },
+                    "focused_graph": {
+                        "schema": "cmind.focused_graph.v1",
+                        "hierarchy": {"id": "focused-graph-root"},
+                        "default_focus": {"node_link_ids": ["rpg-n1-script"]},
+                    },
                 },
                 "primary_rpg_nodes": [
                     {
@@ -298,17 +318,37 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     )
 
     html = report.read_text(encoding="utf-8")
-    assert "Focused nodes map" in html
-    assert "semantic-code impact chain" in html
-    assert html.count("<h2>Focused nodes map</h2>") == 1
-    assert html.count("<h2>semantic-code impact chain</h2>") == 1
+    assert "Focused graph" in html
+    assert "Focused nodes map" not in html
+    assert "semantic-code impact chain" not in html
+    assert html.count("<h2>Focused graph</h2>") == 1
     assert "Why these nodes?" not in html
     assert "Focused impact view" not in html
     assert "What changed?" in html
-    assert "Feature group" in html
-    assert "Semantic → code evidence" in html
+    assert "Focused graph evidence" in html
     assert "focus-map" in html
     assert "One-hop context" in html
+    assert "data-focused-graph-json" in html
+    assert "focused-graph-svg" in html
+    assert "https://d3js.org v7.9.0" in html
+    assert "<script src=" not in html
+    assert "data-action=\"reset\"" in html
+    assert "data-action=\"depth-plus\"" in html
+    assert "data-action=\"depth-minus\"" in html
+    assert "data-action=\"edges\"" in html
+    assert "data-action=\"search\"" in html
+    assert "Reset" in html
+    assert "+1" in html
+    assert "-1" in html
+    assert "Edges" in html
+    assert "Search nodes" in html
+    assert "Static focused graph fallback is available when D3 cannot run." in html
+    assert "semantic_nodes" in html
+    assert "code_nodes" in html
+    assert "mappings" in html
+    assert "hierarchy" in html
+    assert "default_focus" in html
+    assert "focused_graph" in html
     assert "caller.py&lt;script&gt;" in html
     assert "Root / Feature &lt;unsafe&gt;" in html
     assert "NodeSymbol &lt;unsafe&gt;" in html
@@ -323,7 +363,6 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "missing" in html
     assert "n1&lt;script&gt;" in html
     assert "Node &lt;unsafe&gt;" in html
-    assert "feature/&lt;unsafe&gt;" in html
     assert "a.py:f&lt;script&gt;" in html
     assert "a.py&lt;script&gt;" in html
     assert "maps because &lt;reason&gt;" in html
@@ -342,23 +381,53 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "<details><summary>View diff</summary>" in html
     assert "<details open" not in html
     inspector_json = html.split("<summary>Inspector JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
+    assert "focused_graph" in inspector_json
     assert "nodes_view" in inspector_json
     assert "semantic_nodes" in inspector_json
+    assert "hierarchy" in inspector_json
+    assert "default_focus" in inspector_json
     assert "primary_rpg_nodes" not in inspector_json
     assert "primary_code_nodes" not in inspector_json
     assert long_diff not in inspector_json
     evidence_json = html.split("<summary>Evidence JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
     assert "code_deltas" not in evidence_json
     assert "focused_view" not in evidence_json
+    assert "nodes_view" not in evidence_json
     assert "focused_impact" not in evidence_json
     assert "focused_graph" not in evidence_json
     assert long_diff not in evidence_json
-    assert len(html) < 22000
     assert "Focused impact summary" not in html
-    assert "Focused graph evidence" not in html
     assert "Graph artifact" not in html
     assert "Inspector metadata" not in html
-    assert "focused_graph" not in html
+
+
+def test_write_command_report_renders_static_fallback_without_d3(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.setattr(run_report, "_D3_ASSET", tmp_path / "missing-d3.v7.min.js")
+
+    report = write_command_report(
+        {
+            "command": "rpg_edit",
+            "focused_view": {
+                "nodes_view": {
+                    "summary": {"semantic_nodes": 1, "code_nodes": 0, "mappings": 0, "edges": 0, "warnings": 0},
+                    "semantic_nodes": [{"node_id": "n1", "link_id": "rpg-n1", "name": "Node"}],
+                    "code_nodes": [],
+                    "mappings": [],
+                    "edges": [],
+                    "hidden_counts": {},
+                    "warnings": [],
+                }
+            },
+            "timestamp": "fixed",
+        },
+        report_dir=tmp_path,
+    )
+
+    html = report.read_text(encoding="utf-8")
+    assert "Focused graph" in html
+    assert "Local D3 asset missing; showing the static fallback." in html
+    assert "https://d3js.org" not in html
+    assert "Static focused graph fallback is available when D3 cannot run." in html
 
 
 def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:

From fe30e63450d7338184cc9b2f2d06da31a3a04472 Mon Sep 17 00:00:00 2001
From: Yasen Hu <74404492+HuYaSen@users.noreply.github.com>
Date: Mon, 6 Jul 2026 17:45:30 +0800
Subject: [PATCH 24/56] =?UTF-8?q?decoder:=20fix=20abstractmethod=20usage?=
 =?UTF-8?q?=20=E2=80=94=20make=20RepoNode=20ABC=20and=20remove=20abstractm?=
 =?UTF-8?q?ethod=20decorators=20from=20PythonBackend?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CoderMind/scripts/decoder_lang/python_backend.py | 6 ------
 CoderMind/scripts/skeleton/skeleton_models.py    | 4 ++--
 zerorepo/rpg_gen/base/node/node.py               | 4 ++--
 3 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/CoderMind/scripts/decoder_lang/python_backend.py b/CoderMind/scripts/decoder_lang/python_backend.py
index b329e42..06384dd 100644
--- a/CoderMind/scripts/decoder_lang/python_backend.py
+++ b/CoderMind/scripts/decoder_lang/python_backend.py
@@ -14,7 +14,6 @@
 import ast
 import keyword
 import logging
-from abc import abstractmethod
 from pathlib import Path
 from typing import Any
 
@@ -423,7 +422,6 @@ def _source_for_node(source: str, node: ast.AST) -> str:
     # 3. Build / test environment — not wired into the decoder yet
     # ------------------------------------------------------------------
 
-    @abstractmethod
     def detect_env(self, repo_root: Path) -> EnvHandle | None:
         """Return an existing Python test environment when supported."""
         raise NotImplementedError(
@@ -432,7 +430,6 @@ def detect_env(self, repo_root: Path) -> EnvHandle | None:
             "for now.",
         )
 
-    @abstractmethod
     def ensure_env(self, repo_root: Path) -> EnvHandle:
         """Always available on a host that's already running Python
         (the decoder itself), so this never raises
@@ -441,7 +438,6 @@ def ensure_env(self, repo_root: Path) -> EnvHandle:
             "PythonBackend.ensure_env is not wired into the decoder.",
         )
 
-    @abstractmethod
     def test_command(
         self,
         env: EnvHandle,
@@ -454,7 +450,6 @@ def test_command(
             "build_batch_pytest_cmd for now.",
         )
 
-    @abstractmethod
     def install_deps_command(
         self,
         env: EnvHandle,
@@ -469,7 +464,6 @@ def install_deps_command(
     # 4. Test-output parsing — not wired into the decoder yet
     # ------------------------------------------------------------------
 
-    @abstractmethod
     def parse_test_output(self, raw: str, exit_code: int) -> TestRunResult:
         """Parse native Python test output when backend-driven tests run."""
         raise NotImplementedError(
diff --git a/CoderMind/scripts/skeleton/skeleton_models.py b/CoderMind/scripts/skeleton/skeleton_models.py
index 0d34aee..db6d622 100644
--- a/CoderMind/scripts/skeleton/skeleton_models.py
+++ b/CoderMind/scripts/skeleton/skeleton_models.py
@@ -15,7 +15,7 @@
 import json
 import logging
 from typing import List, Optional, Dict, Any
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from pathlib import PurePosixPath
 
 from rpg.code_unit import CodeUnit, ParsedFile
@@ -36,7 +36,7 @@ def normalize_path(path: str) -> str:
     return posix_path
 
 
-class RepoNode:
+class RepoNode(ABC):
     """Base class for repository nodes."""
 
     def __init__(self, name: str, path: str):
diff --git a/zerorepo/rpg_gen/base/node/node.py b/zerorepo/rpg_gen/base/node/node.py
index 04990b2..00b3e07 100644
--- a/zerorepo/rpg_gen/base/node/node.py
+++ b/zerorepo/rpg_gen/base/node/node.py
@@ -1,11 +1,11 @@
 
 from typing import List, Optional, Dict
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 import logging
 from ..unit import CodeUnit, ParsedFile
 from zerorepo.utils.file import normalize_path
 
-class RepoNode:
+class RepoNode(ABC):
     def __init__(self, name: str, path: str):
         self.name = name
         self.path = normalize_path(path)  # 相对路径

From 2c59ad273b6d9643fadd597b57ca6b3077a85c7a Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Mon, 6 Jul 2026 12:08:27 +0000
Subject: [PATCH 25/56] rpg_edit: Harden `generate_html()` around lines 414-454
 and 608-616 by

---
 CoderMind/scripts/rpg_visualize.py    | 112 ++++++++++++++++++--------
 CoderMind/tests/test_rpg_visualize.py | 108 +++++++++++++++++++++++++
 2 files changed, 188 insertions(+), 32 deletions(-)
 create mode 100644 CoderMind/tests/test_rpg_visualize.py

diff --git a/CoderMind/scripts/rpg_visualize.py b/CoderMind/scripts/rpg_visualize.py
index e318073..2a38e2d 100644
--- a/CoderMind/scripts/rpg_visualize.py
+++ b/CoderMind/scripts/rpg_visualize.py
@@ -15,12 +15,41 @@
 """
 
 import argparse
+import html
 import json
 import sys
 from pathlib import Path
 from typing import Any, Dict, List
 
 
+_D3_ASSET = Path(__file__).resolve().parent / "common" / "assets" / "d3.v7.min.js"
+
+
+def _html_escape(value: Any) -> str:
+    return html.escape(str(value), quote=True)
+
+
+def _json_for_script(value: Any) -> str:
+    data = json.dumps(value, ensure_ascii=False)
+    return (
+        data.replace("&", "\\u0026")
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("
", "\\u2028")
+        .replace("
", "\\u2029")
+    )
+
+
+def _inline_d3() -> str:
+    try:
+        source = _D3_ASSET.read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+    if source.startswith("// https://d3js.org"):
+        source = source.split("\n", 1)[1] if "\n" in source else ""
+    return source.replace("</script", "<\\/script")
+
+
 def load_json(path: str | Path) -> dict:
     with open(path, "r", encoding="utf-8") as f:
         return json.load(f)
@@ -417,7 +446,7 @@ def generate_html(data: dict) -> str:
     dep = extract_dep_graph(data)
     dep_tree = build_dep_tree(data)
     dep_to_rpg = data.get("_dep_to_rpg_map", {})
-    repo_name = data.get("repo_name", "Unknown")
+    repo_name_html = _html_escape(data.get("repo_name", "Unknown"))
     feat_node_count = count_nodes(tree)
     feat_edge_count = len(semantic_edges)
 
@@ -426,32 +455,35 @@ def generate_html(data: dict) -> str:
     for e in semantic_edges:
         r = e.get("relation", "unknown")
         edge_types[r] = edge_types.get(r, 0) + 1
-    feat_edge_summary = ", ".join(f"{k}: {v}" for k, v in sorted(edge_types.items()))
+    feat_edge_summary = _html_escape(", ".join(f"{k}: {v}" for k, v in sorted(edge_types.items())))
 
     # Dep stats
     dep_node_count = len(dep["nodes"])
     dep_edge_count = len(dep["edges"])
-    dep_edge_summary = ", ".join(f"{k}: {v}" for k, v in sorted(dep["stats"].items()))
+    dep_edge_summary = _html_escape(", ".join(f"{k}: {v}" for k, v in sorted(dep["stats"].items())))
     has_dep = dep_node_count > 0
 
     map_count = sum(len(v) for v in dep_to_rpg.values())
     has_map = len(dep_to_rpg) > 0
 
-    tree_json = json.dumps(tree)
-    edges_json = json.dumps(semantic_edges)
-    dep_nodes_json = json.dumps(dep["nodes"])
-    dep_edges_json = json.dumps(dep["edges"])
-    dep_parent_json = json.dumps(dep["parent_map"])
-    dep_tree_json = json.dumps(dep_tree)
-    dep_to_rpg_json = json.dumps(dep_to_rpg)
+    tree_json = _json_for_script(tree)
+    edges_json = _json_for_script(semantic_edges)
+    dep_nodes_json = _json_for_script(dep["nodes"])
+    dep_edges_json = _json_for_script(dep["edges"])
+    dep_parent_json = _json_for_script(dep["parent_map"])
+    dep_tree_json = _json_for_script(dep_tree)
+    dep_to_rpg_json = _json_for_script(dep_to_rpg)
+    d3_js = _inline_d3()
 
     return f"""<!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>RPG: {repo_name}</title>
-<script src="https://d3js.org/d3.v7.min.js"></script>
+<title>RPG: {repo_name_html}</title>
+<script>
+{d3_js}
+</script>
 <style>
 * {{ margin: 0; padding: 0; box-sizing: border-box; }}
 body {{ background: #0d1117; color: #c9d1d9; font-family: -apple-system, BlinkMacSystemFont,
@@ -537,7 +569,7 @@ def generate_html(data: dict) -> str:
 </head>
 <body>
 <div id="header">
-  <h1>RPG: {repo_name}</h1>
+  <h1>RPG: {repo_name_html}</h1>
   <div id="tabs">
     <button id="tab-feat" class="active" onclick="switchTab('feat')">Feat Graph</button>
     <button id="tab-dep" onclick="switchTab('dep')">Dep Graph</button>
@@ -639,6 +671,17 @@ def generate_html(data: dict) -> str:
   inherits: 'dep-link-inherits',
 }};
 
+const htmlEscapes = {{
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+}};
+function escapeHtml(value) {{
+  return String(value ?? '').replace(/[&<>"']/g, ch => htmlEscapes[ch]);
+}}
+
 const margin = {{ top: 50, right: 200, bottom: 20, left: 80 }};
 const svg = d3.select('#canvas');
 const width = window.innerWidth;
@@ -820,17 +863,21 @@ def generate_html(data: dict) -> str:
   const path = meta.path || '';
   const desc = meta.description || '';
   const connected = semanticEdges.filter(e => e.src === d.data.id || e.dst === d.data.id);
+  const relations = [...new Set(connected.map(e => e.relation || 'unknown'))]
+    .map(escapeHtml).join(', ');
   const edgeInfo = connected.length > 0
-    ? `<div class="tt-edges">${{connected.length}} edge(s): ${{
-        [...new Set(connected.map(e => e.relation))].join(', ')
-      }}</div>` : '';
+    ? `<div class="tt-edges">${{connected.length}} edge(s): ${{relations}}</div>` : '';
+  const typeInfo = tn ? `<div class="tt-type">${{escapeHtml(tn)}}</div>` : '';
+  const pathInfo = path && path !== '.' ? `<div class="tt-path">${{escapeHtml(path)}}</div>` : '';
+  const descInfo = desc ? `<div style="color:#8b949e;font-size:11px;margin-top:2px">${{escapeHtml(desc.slice(0, 200))}}</div>` : '';
+  const collapsedInfo = d._children ? `<div style="color:#1f6feb;font-size:11px">${{d._children.length}} children (collapsed)</div>` : '';
   tip.innerHTML = `
-    <div class="tt-name">${{d.data.name || d.data.id}}</div>
-    ${{tn ? `<div class="tt-type">${{tn}}</div>` : ''}}
-    ${{path && path !== '.' ? `<div class="tt-path">${{path}}</div>` : ''}}
-    ${{desc ? `<div style="color:#8b949e;font-size:11px;margin-top:2px">${{desc.slice(0, 200)}}</div>` : ''}}
+    <div class="tt-name">${{escapeHtml(d.data.name || d.data.id)}}</div>
+    ${{typeInfo}}
+    ${{pathInfo}}
+    ${{descInfo}}
     ${{edgeInfo}}
-    ${{d._children ? `<div style="color:#1f6feb;font-size:11px">${{d._children.length}} children (collapsed)</div>` : ''}}
+    ${{collapsedInfo}}
   `;
   tip.style.display = 'block';
   tip.style.left = (event.clientX + 12) + 'px';
@@ -1474,8 +1521,8 @@ def generate_html(data: dict) -> str:
       const tip = document.getElementById('tooltip');
       const descCount = (depAllDescendants[d.id] || new Set()).size;
       tip.innerHTML = `
-        <div class="tt-name">${{d.name || d.id}}</div>
-        <div class="tt-type">${{d.type}}</div>
+        <div class="tt-name">${{escapeHtml(d.name || d.id)}}</div>
+        <div class="tt-type">${{escapeHtml(d.type)}}</div>
         <div style="color:#8b949e;font-size:11px">Click to select · Double-click to collapse (${{descCount}} nodes)</div>
       `;
       tip.style.display = 'block';
@@ -1513,19 +1560,20 @@ def generate_html(data: dict) -> str:
 function showTooltipDep(event, d) {{
   const tip = document.getElementById('tooltip');
   const rpgInfo = d.rpg_nodes && d.rpg_nodes.length > 0
-    ? `<div style="color:#79c0ff;font-size:11px;margin-top:2px">RPG nodes: ${{d.rpg_nodes.join(', ')}}</div>` : '';
+    ? `<div style="color:#79c0ff;font-size:11px;margin-top:2px">RPG nodes: ${{d.rpg_nodes.map(escapeHtml).join(', ')}}</div>` : '';
 
   const descCount = d.isCollapsed ? (depAllDescendants[d.id] || new Set()).size : 0;
   const collapseInfo = d.isCollapsed
     ? `<div style="color:#1f6feb;font-size:11px">${{descCount}} nodes collapsed (double-click to expand)</div>` : '';
   const expandInfo = d.hasChildren && !d.isCollapsed
     ? `<div style="color:#8b949e;font-size:11px">Double-click to collapse</div>` : '';
+  const moduleInfo = d.module ? `<div style="color:#8b949e;font-size:11px">${{escapeHtml(d.module)}}</div>` : '';
 
   tip.innerHTML = `
-    <div class="tt-name">${{d.name || d.id}}</div>
-    <div class="tt-type">${{d.type}}</div>
-    <div class="tt-path">${{d.id}}</div>
-    ${{d.module ? `<div style="color:#8b949e;font-size:11px">${{d.module}}</div>` : ''}}
+    <div class="tt-name">${{escapeHtml(d.name || d.id)}}</div>
+    <div class="tt-type">${{escapeHtml(d.type)}}</div>
+    <div class="tt-path">${{escapeHtml(d.id)}}</div>
+    ${{moduleInfo}}
     ${{collapseInfo}}
     ${{expandInfo}}
     ${{rpgInfo}}
@@ -1804,7 +1852,7 @@ def generate_html(data: dict) -> str:
   const connected = mapEdges.filter(e => side === 'feat' ? e.feat_id === nodeId : e.dep_id === nodeId);
   if (connected.length === 0) {{
     const tip = document.getElementById('tooltip');
-    tip.innerHTML = `<div class="tt-name">${{nodeId}}</div><div class="tt-type" style="color:#484f58">No mapping</div>`;
+    tip.innerHTML = `<div class="tt-name">${{escapeHtml(nodeId)}}</div><div class="tt-type" style="color:#484f58">No mapping</div>`;
     tip.style.display = 'block';
     tip.style.left = (event.clientX + 12) + 'px';
     tip.style.top = (event.clientY - 10) + 'px';
@@ -1835,9 +1883,9 @@ def generate_html(data: dict) -> str:
 
   const tip = document.getElementById('tooltip');
   const names = side === 'feat'
-    ? connected.map(e => e.dep_id).join('<br>')
-    : connected.map(e => e.feat_id).join('<br>');
-  tip.innerHTML = `<div class="tt-name">${{nodeId}}</div>
+    ? connected.map(e => escapeHtml(e.dep_id)).join('<br>')
+    : connected.map(e => escapeHtml(e.feat_id)).join('<br>');
+  tip.innerHTML = `<div class="tt-name">${{escapeHtml(nodeId)}}</div>
     <div class="tt-type">${{connected.length}} mapping(s)</div>
     <div class="tt-path">${{names}}</div>`;
   tip.style.display = 'block';
diff --git a/CoderMind/tests/test_rpg_visualize.py b/CoderMind/tests/test_rpg_visualize.py
new file mode 100644
index 0000000..81dbc11
--- /dev/null
+++ b/CoderMind/tests/test_rpg_visualize.py
@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_REPO = Path(__file__).resolve().parents[1]
+_SCRIPTS = _REPO / "scripts"
+if str(_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS))
+
+from rpg_visualize import generate_html
+
+
+RAW_SCRIPT = "<script>alert(1)</script>"
+SCRIPT_BREAKOUT = "</script><script>alert(1)</script>"
+
+
+def _malicious_data() -> dict:
+    feature_id = f"feature::{SCRIPT_BREAKOUT}"
+    dep_id = f"pkg/mod.py:func::{SCRIPT_BREAKOUT}"
+    other_dep_id = f"pkg/other.py:other::{RAW_SCRIPT}"
+    return {
+        "repo_name": f"Repo {RAW_SCRIPT}",
+        "root": {
+            "id": "root",
+            "name": "Root",
+            "node_type": "repository",
+            "meta": {"path": "."},
+            "children": [
+                {
+                    "id": feature_id,
+                    "name": f"Feature {SCRIPT_BREAKOUT}",
+                    "node_type": "feature",
+                    "meta": {
+                        "type_name": f"type {RAW_SCRIPT}",
+                        "path": f"features/{RAW_SCRIPT}",
+                        "description": f"Description {SCRIPT_BREAKOUT}",
+                    },
+                    "children": [],
+                }
+            ],
+        },
+        "edges": [
+            {
+                "src": feature_id,
+                "dst": "root",
+                "relation": f"references {RAW_SCRIPT}",
+            }
+        ],
+        "dep_graph": {
+            "nodes": {
+                ".": {"name": ".", "type": "directory"},
+                "pkg": {"name": f"pkg {RAW_SCRIPT}", "type": "directory"},
+                "pkg/mod.py": {
+                    "name": f"mod.py {RAW_SCRIPT}",
+                    "type": "file",
+                    "module": f"pkg.mod {RAW_SCRIPT}",
+                },
+                dep_id: {
+                    "name": f"func {SCRIPT_BREAKOUT}",
+                    "type": "function",
+                    "module": f"pkg.mod {SCRIPT_BREAKOUT}",
+                    "rpg_nodes": [f"rpg-node {RAW_SCRIPT}"],
+                },
+                other_dep_id: {
+                    "name": f"other {RAW_SCRIPT}",
+                    "type": "function",
+                    "module": f"pkg.other {RAW_SCRIPT}",
+                },
+            },
+            "edges": [
+                {"src": ".", "dst": "pkg", "attrs": {"type": "contains"}},
+                {"src": "pkg", "dst": "pkg/mod.py", "attrs": {"type": "contains"}},
+                {"src": "pkg/mod.py", "dst": dep_id, "attrs": {"type": "contains"}},
+                {"src": "pkg", "dst": other_dep_id, "attrs": {"type": "contains"}},
+                {"src": dep_id, "dst": other_dep_id, "attrs": {"type": f"invokes {RAW_SCRIPT}"}},
+            ],
+        },
+        "_dep_to_rpg_map": {dep_id: [feature_id]},
+    }
+
+
+def test_generate_html_escapes_html_and_script_contexts() -> None:
+    html = generate_html(_malicious_data())
+
+    assert "Repo &lt;script&gt;alert(1)&lt;/script&gt;" in html
+    assert "\\u003cscript\\u003ealert(1)\\u003c/script\\u003e" in html
+    assert "\\u003c/script\\u003e\\u003cscript\\u003ealert(1)\\u003c/script\\u003e" in html
+    assert RAW_SCRIPT not in html
+    assert SCRIPT_BREAKOUT not in html
+    assert "https://d3js.org" not in html
+    assert 'src="https://d3js.org/d3.v7.min.js"' not in html
+
+
+def test_generate_html_tooltip_builders_escape_graph_controlled_values() -> None:
+    html = generate_html(_malicious_data())
+
+    assert "escapeHtml(d.data.name || d.data.id)" in html
+    assert "escapeHtml(tn)" in html
+    assert "escapeHtml(path)" in html
+    assert "escapeHtml(desc.slice(0, 200))" in html
+    assert "connected.map(e => e.relation || 'unknown')" in html
+    assert "map(escapeHtml).join(', ')" in html
+    assert "escapeHtml(d.name || d.id)" in html
+    assert "escapeHtml(d.module)" in html
+    assert "escapeHtml(nodeId)" in html
+    assert "escapeHtml(e.dep_id)" in html
+    assert "escapeHtml(e.feat_id)" in html

From 0f82b73c56f6016dbe3f17e0c1914dbb6e597bcd Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Mon, 6 Jul 2026 12:21:46 +0000
Subject: [PATCH 26/56] rpg_edit: preserve bundled D3 attribution

Keep the locally bundled D3 source intact while still asserting that generated RPG reports do not load D3 from the CDN.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/rpg_visualize.py    | 2 --
 CoderMind/tests/test_rpg_visualize.py | 3 ++-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/CoderMind/scripts/rpg_visualize.py b/CoderMind/scripts/rpg_visualize.py
index 2a38e2d..d5849a7 100644
--- a/CoderMind/scripts/rpg_visualize.py
+++ b/CoderMind/scripts/rpg_visualize.py
@@ -45,8 +45,6 @@ def _inline_d3() -> str:
         source = _D3_ASSET.read_text(encoding="utf-8").strip()
     except OSError:
         return ""
-    if source.startswith("// https://d3js.org"):
-        source = source.split("\n", 1)[1] if "\n" in source else ""
     return source.replace("</script", "<\\/script")
 
 
diff --git a/CoderMind/tests/test_rpg_visualize.py b/CoderMind/tests/test_rpg_visualize.py
index 81dbc11..9b5e492 100644
--- a/CoderMind/tests/test_rpg_visualize.py
+++ b/CoderMind/tests/test_rpg_visualize.py
@@ -88,7 +88,8 @@ def test_generate_html_escapes_html_and_script_contexts() -> None:
     assert "\\u003c/script\\u003e\\u003cscript\\u003ealert(1)\\u003c/script\\u003e" in html
     assert RAW_SCRIPT not in html
     assert SCRIPT_BREAKOUT not in html
-    assert "https://d3js.org" not in html
+    assert "https://d3js.org v7.9.0" in html
+    assert '<script src="https://d3js.org' not in html
     assert 'src="https://d3js.org/d3.v7.min.js"' not in html
 
 

From 4e0c966315cb1229f94b9e3c0db1ae58abfc42d6 Mon Sep 17 00:00:00 2001
From: Yasen Hu <74404492+HuYaSen@users.noreply.github.com>
Date: Mon, 6 Jul 2026 22:26:18 +0800
Subject: [PATCH 27/56] rpg_edit: guard rollback-branch to rpg-edit/* and add
 regression test

---
 CoderMind/scripts/rpg_edit/apply.py         |  6 ++++-
 CoderMind/tests/test_rpg_edit_run_report.py | 26 +++++++++++++++++++++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/CoderMind/scripts/rpg_edit/apply.py b/CoderMind/scripts/rpg_edit/apply.py
index 8f60827..cb6d1c5 100644
--- a/CoderMind/scripts/rpg_edit/apply.py
+++ b/CoderMind/scripts/rpg_edit/apply.py
@@ -59,12 +59,16 @@ def _rollback(backups: Dict[str, str], rpg_path: Path, dep_graph_path: Path) ->
         shutil.copy2(backups["dep_graph"], dep_graph_path)
 
 
+def _is_rpg_edit_branch(branch: Any) -> bool:
+    return isinstance(branch, str) and branch.startswith("rpg-edit/")
+
+
 def _rollback_command(timestamp: str | None, before_state: dict | None) -> str | None:
     if not timestamp:
         return None
     command = f"{cmd_for('rpg_edit/apply.py')} --rollback {shlex.quote(str(timestamp))}"
     branch = before_state.get("head_branch") if isinstance(before_state, dict) else None
-    if branch:
+    if _is_rpg_edit_branch(branch):
         command += f" --rollback-branch {shlex.quote(str(branch))}"
     return command
 
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index b0c91c0..b0dfad7 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -214,6 +214,32 @@ def fake_write_command_report(run):
     assert persisted["report_path"] == str(report_path)
 
 
+def test_rollback_command_only_uses_rpg_edit_branch(tmp_path: Path, monkeypatch) -> None:
+    apply_module = _load_script("rpg_edit_apply_test", _SCRIPTS / "rpg_edit" / "apply.py")
+
+    result = apply_module._rollback_command(
+        "123",
+        {
+            "head_commit": "before123",
+            "head_short": "before1",
+            "head_branch": "feature/my-branch",
+            "head_timestamp": "2026-06-30T12:00:00+00:00",
+        },
+    )
+    assert result == "cmind script rpg_edit/apply.py --rollback 123"
+
+    result = apply_module._rollback_command(
+        "123",
+        {
+            "head_commit": "before123",
+            "head_short": "before1",
+            "head_branch": "rpg-edit/test",
+            "head_timestamp": "2026-06-30T12:00:00+00:00",
+        },
+    )
+    assert result == "cmind script rpg_edit/apply.py --rollback 123 --rollback-branch rpg-edit/test"
+
+
 def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path: Path, monkeypatch) -> None:
     review = _load_script("rpg_edit_review_impact_test", _SCRIPTS / "rpg_edit" / "review.py")
 

From 8d43e1884b45669f136a7f6a14f055d70a07b130 Mon Sep 17 00:00:00 2001
From: Yasen Hu <74404492+HuYaSen@users.noreply.github.com>
Date: Mon, 6 Jul 2026 22:27:59 +0800
Subject: [PATCH 28/56] update_graphs: prefer explicit status or infer 'error'
 when result contains error

---
 CoderMind/scripts/update_graphs.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index 825e955..fa5929a 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -171,7 +171,7 @@ def _attach_update_report(result: dict) -> dict:
         report_path = write_command_report(CommandRun(
             command="update_rpg",
             title="CoderMind update_rpg Explain View",
-            status=result.get("status", result.get("mode")),
+            status=result.get("status") or ("error" if result.get("error") else result.get("mode")),
             summary=[
                 {"label": "mode", "value": result.get("mode", "")},
                 {
@@ -210,7 +210,7 @@ def _attach_update_report(result: dict) -> dict:
                 ),
                 StepEvent(
                     name="sync graph",
-                    status=result.get("status", result.get("mode", "")),
+                    status=result.get("status") or ("error" if result.get("error") else result.get("mode", "")),
                     reason=result.get("reason", ""),
                 ),
                 StepEvent(
@@ -230,7 +230,7 @@ def _attach_update_report(result: dict) -> dict:
                 ArtifactEvent(label="rpg_html", path=result.get("viz_path")),
             ],
             verification=[
-                VerificationEvent(name="update_rpg", status=result.get("status", result.get("mode"))),
+                VerificationEvent(name="update_rpg", status=result.get("status") or ("error" if result.get("error") else result.get("mode"))),
                 VerificationEvent(name="viz", status=viz_status),
             ],
             evidence=result,

From bce3c6ae9b19d44f149044f92f8e12fb18a26adc Mon Sep 17 00:00:00 2001
From: Yasen Hu <74404492+HuYaSen@users.noreply.github.com>
Date: Mon, 6 Jul 2026 22:29:21 +0800
Subject: [PATCH 29/56] plan: preserve state.message for warnings instead of
 overwriting reason

---
 CoderMind/scripts/plan.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CoderMind/scripts/plan.py b/CoderMind/scripts/plan.py
index 9ec9efc..a6ad4aa 100644
--- a/CoderMind/scripts/plan.py
+++ b/CoderMind/scripts/plan.py
@@ -291,7 +291,11 @@ def decide(states: list[StageState], force: bool) -> None:
             state.reason = "up-to-date"
         else:
             state.will_run = True
-            state.reason = f"type={state.type}"
+            # Preserve useful messages for warnings (don't overwrite state.message)
+            if state.message:
+                state.reason = state.message
+            else:
+                state.reason = f"type={state.type}"
             cascade = True
 
 

From 95799455729d1ee978d89275ee61a027a726c9a2 Mon Sep 17 00:00:00 2001
From: Yasen Hu <74404492+HuYaSen@users.noreply.github.com>
Date: Tue, 7 Jul 2026 00:00:11 +0800
Subject: [PATCH 30/56] update_graphs: make _git_delta_files use --relative for
 subdirectory workspaces

---
 CoderMind/scripts/update_graphs.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index fa5929a..0f48fb2 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -127,7 +127,7 @@ def _git_delta_files(prev_ref: str, workspace_root: str) -> list[dict[str, str]]
 
     try:
         output = subprocess.check_output(
-            ["git", "diff", "--name-status", f"{prev_ref}..HEAD", "--", "."],
+            ["git", "diff", "--relative", "--name-status", f"{prev_ref}..HEAD", "--", "."],
             cwd=workspace_root,
             stderr=subprocess.DEVNULL,
             text=True,

From 3d5038a767e374fc176172dfba2620af08972273 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Tue, 7 Jul 2026 03:41:57 +0000
Subject: [PATCH 31/56] rpg_edit: In _expected_report_path() around lines
 117-118, stop buildi

---
 CoderMind/scripts/rpg_edit/review.py        | 13 +++++++++----
 CoderMind/tests/test_rpg_edit_run_report.py | 10 ++++++++--
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index e6fa182..49c8687 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -114,8 +114,12 @@ def _report_filename_slug(value: str) -> str:
     return slug or "command"
 
 
-def _expected_report_path(report_dir: Path, run_id: str) -> Path:
-    return report_dir / f"cmind_run_rpg_edit_{_report_filename_slug(run_id)}.html"
+def _report_timestamp() -> str:
+    return time.strftime("%Y%m%dT%H%M%SZ", time.gmtime())
+
+
+def _expected_report_path(report_dir: Path, report_timestamp: str) -> Path:
+    return report_dir / f"cmind_run_rpg_edit_{_report_filename_slug(report_timestamp)}.html"
 
 
 def _load_existing_review_result() -> Dict[str, Any]:
@@ -1688,7 +1692,8 @@ def _publish_review_report(
         return result
 
     target_report_dir = _report_target_dir(report_scope, report_dir)
-    result["published_to"] = str(_expected_report_path(target_report_dir, run_id))
+    report_timestamp = _report_timestamp()
+    result["published_to"] = str(_expected_report_path(target_report_dir, report_timestamp))
     _write_review_result(result)
 
     artifacts = _load_review_artifacts(plan_path, impact_path)
@@ -1702,7 +1707,7 @@ def _publish_review_report(
             command="rpg_edit",
             title="CoderMind rpg_edit Explain View",
             status=str(result.get("type", "review")),
-            timestamp=run_id,
+            timestamp=report_timestamp,
             summary=_review_summary_cards(result, artifacts, focused_view),
             steps=[
                 StepEvent(name=row.get("name", "stage"), status=row.get("status"), reason=row.get("reason", ""))
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 020587b..8e8f640 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -622,6 +622,8 @@ def test_review_report_scope_internal_writes_under_internal_report_dir(tmp_path:
     review = _load_script("rpg_edit_review_scope_internal_test", _SCRIPTS / "rpg_edit" / "review.py")
     plan_path, impact_path, review_path = _patch_minimal_review_report(review, tmp_path, monkeypatch)
     captured: dict[str, dict] = {}
+    report_timestamp = "20260707T123456Z"
+    monkeypatch.setattr(review, "_report_timestamp", lambda: report_timestamp)
 
     def fake_write_command_report(run):
         data = run.to_dict()
@@ -647,11 +649,15 @@ def fake_write_command_report(run):
     assert result["internal_report_paths"] == [result["report_path"]]
     assert result["report_scope"] == "internal"
     assert result["is_final"] is False
-    evidence = captured["data"]["evidence"]
+    data = captured["data"]
+    assert data["timestamp"] == report_timestamp
+    evidence = data["evidence"]
     assert evidence["report_scope"] == "internal"
     assert evidence["is_final"] is False
     assert evidence["parent_run_id"] == "parent-2"
-    assert evidence["published_to"].startswith(str(tmp_path / "reports" / "internal" / "cmind_run_rpg_edit_"))
+    expected_published_to = tmp_path / "reports" / "internal" / f"cmind_run_rpg_edit_{report_timestamp}.html"
+    assert evidence["published_to"] == str(expected_published_to)
+    assert result["run_id"] not in evidence["published_to"]
     persisted = json.loads(review_path.read_text(encoding="utf-8"))
     assert persisted["internal_report_paths"] == [result["report_path"]]
 

From f1a87c9aae797d1db73ceddaffaf80fc4cee70b7 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Tue, 7 Jul 2026 06:34:46 +0000
Subject: [PATCH 32/56] rpg_edit: Modify `_focused_graph_runtime()` at
 scripts/common/run_repo

---
 CoderMind/scripts/common/run_report.py | 317 +++++++++++++++++++++----
 CoderMind/tests/test_run_report.py     |  19 ++
 2 files changed, 293 insertions(+), 43 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 988d2eb..d383f9a 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -384,7 +384,18 @@ def _render_page(
 .focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid var(--line); border-radius:8px; background:#fff; color:var(--text); padding:6px 10px; font:inherit; }}
 .focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); }}
 .focused-graph-stage {{ border:1px solid var(--line); border-radius:12px; background:#fbfdff; min-height:480px; position:relative; overflow:hidden; }}
-.focused-graph-svg {{ display:block; width:100%; height:480px; }}
+.focused-graph-svg {{ display:block; width:100%; height:480px; cursor:grab; touch-action:none; }}
+.focused-graph-svg:active {{ cursor:grabbing; }}
+.focused-graph-link {{ transition:opacity .15s ease, stroke-width .15s ease; }}
+.focused-graph-link.active {{ opacity:1; stroke:#0f172a; stroke-width:2.6; }}
+.focused-graph-link.dimmed {{ opacity:.14; }}
+.focused-graph-link.hidden {{ display:none; }}
+.focused-graph-node {{ cursor:pointer; transition:opacity .15s ease; }}
+.focused-graph-node circle {{ transition:stroke .15s ease, stroke-width .15s ease; }}
+.focused-graph-node.selected circle, .focused-graph-node.active circle {{ stroke:#0f172a; stroke-width:3; }}
+.focused-graph-node.dragging {{ cursor:grabbing; }}
+.focused-graph-node.dimmed {{ opacity:.18; }}
+.focused-graph-node.hidden {{ display:none; }}
 .focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed var(--line); border-radius:10px; background:#fff; color:var(--muted); }}
 .focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; }}
 .legend-item {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); font-size:13px; }}
@@ -1054,59 +1065,279 @@ def _focused_graph_runtime() -> str:
   if (!window.d3 || !dataEl || !svg) return;
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
-  const ns = 'http://www.w3.org/2000/svg';
-  let scale = 1;
-  let showEdges = true;
+  const width = Number(svg.getAttribute('width')) || 960;
+  const height = Number(svg.getAttribute('height')) || 480;
+  const defaultFocus = data.default_focus || {};
+  const defaultShowEdges = defaultFocus.show_edges !== false;
+  const text = value => value === undefined || value === null ? '' : String(value);
+  const list = value => Array.isArray(value) ? value : [];
+  let hierarchyDepth = Math.max(0, Number(defaultFocus.hierarchy_depth ?? defaultFocus.edge_depth ?? 1) || 0);
+  const defaultHierarchyDepth = hierarchyDepth;
+  let showEdges = defaultShowEdges;
   let query = '';
-  function make(tag, attrs, text) {
-    const el = document.createElementNS(ns, tag);
-    Object.entries(attrs || {}).forEach(([key, value]) => el.setAttribute(key, value));
-    if (text !== undefined) el.textContent = text;
-    return el;
-  }
+  let selectedId = null;
+  let visibleNodeIds = new Set();
+  const collapsedHierarchyIds = new Set();
+  const nodes = list(data.nodes).map((node, index) => ({
+    ...node,
+    id: text(node.id || node.node_id || `node-${index + 1}`),
+    kind: text(node.kind || 'context'),
+    label: text(node.label || node.name || node.node_id || node.id || `node-${index + 1}`),
+  }));
+  const nodeById = new Map(nodes.map(node => [node.id, node]));
+  const links = list(data.links).map((link, index) => {
+    const source = text(link.source && link.source.id ? link.source.id : link.source);
+    const target = text(link.target && link.target.id ? link.target.id : link.target);
+    return {...link, id: text(link.id || `link-${index + 1}`), source, target};
+  }).filter(link => nodeById.has(link.source) && nodeById.has(link.target));
+  const hierarchyNodeById = new Map();
+  const hierarchyParentById = new Map();
+  const hierarchyChildrenById = new Map();
+  const hierarchyDepthById = new Map();
+  const hierarchyAncestorsById = new Map();
+  const rootHierarchyId = text(data.hierarchy && data.hierarchy.id);
+  const adjacency = new Map(nodes.map(node => [node.id, new Set()]));
+  const linksByNode = new Map(nodes.map(node => [node.id, new Set()]));
+
   function fill(kind) {
     return kind === 'semantic' ? '#2563eb' : kind === 'code' ? '#16a34a' : kind === 'mapping' ? '#f59e0b' : '#64748b';
   }
-  function layout(nodes) {
+  function linkKey(link) {
+    return text(link.id || `${link.source}-${link.target}`);
+  }
+  function collectHierarchy(row, parentId, depth, ancestors) {
+    if (!row || typeof row !== 'object') return;
+    const id = text(row.id || row.link_id || row.node_id);
+    if (!id) return;
+    const children = list(row.children).map(child => text(child && (child.id || child.link_id || child.node_id))).filter(Boolean);
+    hierarchyNodeById.set(id, row);
+    hierarchyChildrenById.set(id, children);
+    hierarchyDepthById.set(id, depth);
+    hierarchyAncestorsById.set(id, ancestors);
+    if (parentId) hierarchyParentById.set(id, parentId);
+    list(row.children).forEach(child => collectHierarchy(child, id, depth + 1, ancestors.concat(id)));
+  }
+  collectHierarchy(data.hierarchy, '', 0, []);
+  let maxHierarchyDepth = Math.max(1, defaultHierarchyDepth);
+  hierarchyDepthById.forEach(depth => { maxHierarchyDepth = Math.max(maxHierarchyDepth, depth); });
+  const maxDepth = Math.max(maxHierarchyDepth, Math.min(Math.max(nodes.length - 1, 1), 8));
+
+  links.forEach(link => {
+    adjacency.get(link.source)?.add(link.target);
+    adjacency.get(link.target)?.add(link.source);
+    linksByNode.get(link.source)?.add(linkKey(link));
+    linksByNode.get(link.target)?.add(linkKey(link));
+  });
+
+  const defaultFocusIds = new Set(list(defaultFocus.node_link_ids).map(text).filter(id => nodeById.has(id)));
+  const semanticFocusIds = new Set(list(defaultFocus.semantic_node_ids).map(text));
+  const codeFocusIds = new Set(list(defaultFocus.code_node_ids).map(text));
+  const mappingFocusIds = new Set(list(defaultFocus.mapping_link_ids).map(text));
+  nodes.forEach(node => {
+    if (semanticFocusIds.has(text(node.node_id)) || codeFocusIds.has(text(node.node_id)) || mappingFocusIds.has(node.id)) {
+      defaultFocusIds.add(node.id);
+    }
+  });
+
+  function layout(rows) {
     const groups = {semantic: [], mapping: [], code: [], context: []};
-    nodes.forEach(node => (groups[node.kind] || groups.context).push(node));
+    rows.forEach(node => (groups[node.kind] || groups.context).push(node));
     const x = {semantic: 150, mapping: 420, code: 690, context: 840};
-    Object.entries(groups).forEach(([kind, rows]) => {
-      const gap = Math.max(44, Math.min(78, 380 / Math.max(rows.length, 1)));
-      const start = 240 - ((rows.length - 1) * gap) / 2;
-      rows.forEach((node, index) => { node.x = x[kind] || 500; node.y = start + index * gap; });
+    Object.entries(groups).forEach(([kind, groupRows]) => {
+      const gap = Math.max(44, Math.min(78, 380 / Math.max(groupRows.length, 1)));
+      const start = height / 2 - ((groupRows.length - 1) * gap) / 2;
+      groupRows.forEach((node, index) => { node.x = x[kind] || width / 2; node.y = start + index * gap; });
     });
   }
-  function render() {
-    const nodes = (data.nodes || []).map(node => ({...node}));
-    const byId = new Map(nodes.map(node => [node.id, node]));
-    layout(nodes);
-    while (svg.firstChild) svg.removeChild(svg.firstChild);
-    svg.setAttribute('viewBox', `0 0 ${960 / scale} ${480 / scale}`);
-    const links = data.links || [];
-    if (showEdges) {
-      links.forEach(link => {
-        const source = byId.get(link.source), target = byId.get(link.target);
-        if (!source || !target) return;
-        const line = make('line', {x1: source.x, y1: source.y, x2: target.x, y2: target.y, stroke: link.kind === 'mapping' ? '#f59e0b' : '#94a3b8', 'stroke-width': link.kind === 'mapping' ? 2 : 1.4, opacity: .78});
-        svg.appendChild(line);
+
+  function expandFromFocus(seedIds, depthLimit) {
+    const visible = new Set([...seedIds].filter(id => nodeById.has(id)));
+    let frontier = new Set(visible);
+    for (let depth = 0; depth < depthLimit && frontier.size; depth += 1) {
+      const next = new Set();
+      frontier.forEach(id => (adjacency.get(id) || new Set()).forEach(neighbor => {
+        if (!visible.has(neighbor)) {
+          visible.add(neighbor);
+          next.add(neighbor);
+        }
+      }));
+      frontier = next;
+    }
+    return visible;
+  }
+
+  function nodeMatches(node) {
+    if (!query) return true;
+    return `${node.label} ${node.node_id || ''} ${node.path || ''} ${node.kind || ''}`.toLowerCase().includes(query);
+  }
+
+  function isCollapsed(nodeId) {
+    if (collapsedHierarchyIds.has(nodeId)) return true;
+    return list(hierarchyAncestorsById.get(nodeId)).some(id => collapsedHierarchyIds.has(id));
+  }
+
+  function nearestHierarchyToggle(nodeId) {
+    return nodeId !== rootHierarchyId && (hierarchyChildrenById.get(nodeId) || []).length ? nodeId : '';
+  }
+
+  function computeVisibleNodeIds() {
+    const seeds = defaultFocusIds.size ? defaultFocusIds : new Set(nodes.map(node => node.id));
+    const visible = expandFromFocus(seeds, hierarchyDepth);
+    if (hierarchyNodeById.size) {
+      nodes.forEach(node => {
+        const depth = hierarchyDepthById.get(node.id);
+        if (depth !== undefined && depth <= hierarchyDepth) visible.add(node.id);
       });
     }
+    if (query) nodes.forEach(node => { if (nodeMatches(node)) visible.add(node.id); });
     nodes.forEach(node => {
-      const matches = !query || `${node.label} ${node.node_id || ''} ${node.path || ''}`.toLowerCase().includes(query);
-      const group = make('g', {transform: `translate(${node.x},${node.y})`, opacity: matches ? '1' : '.18'});
-      group.appendChild(make('circle', {r: node.kind === 'mapping' ? 6 : 8, fill: fill(node.kind), stroke: '#fff', 'stroke-width': 2}));
-      group.appendChild(make('text', {x: 13, y: 4, 'font-size': 12, fill: '#1f2937'}, (node.label || node.id || '').slice(0, 42)));
-      group.appendChild(make('title', {}, `${node.kind}: ${node.label || node.id}`));
-      svg.appendChild(group);
+      if (!nodeMatches(node) || isCollapsed(node.id)) visible.delete(node.id);
     });
+    if (!visible.size && !query) nodes.forEach(node => { if (!isCollapsed(node.id)) visible.add(node.id); });
+    return visible;
   }
-  section.querySelector('[data-action="reset"]')?.addEventListener('click', () => { scale = 1; query = ''; showEdges = true; const search = section.querySelector('[data-action="search"]'); if (search) search.value = ''; const edges = section.querySelector('[data-action="edges"]'); if (edges) edges.checked = true; render(); });
-  section.querySelector('[data-action="depth-plus"]')?.addEventListener('click', () => { scale = Math.min(1.8, scale + .15); render(); });
-  section.querySelector('[data-action="depth-minus"]')?.addEventListener('click', () => { scale = Math.max(.7, scale - .15); render(); });
-  section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; render(); });
-  section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = event.target.value.toLowerCase(); render(); });
-  render();
+
+  function isLinkVisible(link) {
+    return showEdges && visibleNodeIds.has(link.source) && visibleNodeIds.has(link.target);
+  }
+
+  layout(nodes);
+  const svgSelection = d3.select(svg).attr('viewBox', `0 0 ${width} ${height}`);
+  svgSelection.selectAll('*').remove();
+  const graphLayer = svgSelection.append('g').attr('class', 'focused-graph-layer');
+  const linkLayer = graphLayer.append('g').attr('class', 'focused-graph-links');
+  const nodeLayer = graphLayer.append('g').attr('class', 'focused-graph-nodes');
+  const zoom = d3.zoom()
+    .scaleExtent([0.35, 3.5])
+    .on('zoom', event => graphLayer.attr('transform', event.transform));
+  svgSelection.call(zoom).on('dblclick.zoom', null).on('click', event => {
+    if (event.target === svg) {
+      selectedId = null;
+      renderVisibility();
+    }
+  });
+
+  const linkSelection = linkLayer.selectAll('line')
+    .data(links, link => linkKey(link))
+    .join('line')
+    .attr('class', 'focused-graph-link')
+    .attr('data-link-id', link => linkKey(link))
+    .attr('stroke', link => link.kind === 'mapping' ? '#f59e0b' : '#94a3b8')
+    .attr('stroke-width', link => link.kind === 'mapping' ? 2 : 1.4)
+    .attr('opacity', .78);
+
+  const drag = d3.drag()
+    .container(() => graphLayer.node())
+    .on('start', function(event) {
+      event.sourceEvent?.stopPropagation();
+      d3.select(this).classed('dragging', true);
+    })
+    .on('drag', function(event, node) {
+      node.x = event.x;
+      node.y = event.y;
+      updatePositions();
+    })
+    .on('end', function() {
+      d3.select(this).classed('dragging', false);
+    });
+
+  const nodeSelection = nodeLayer.selectAll('g')
+    .data(nodes, node => node.id)
+    .join(enter => {
+      const group = enter.append('g')
+        .attr('class', 'focused-graph-node')
+        .attr('data-node-id', node => node.id)
+        .attr('tabindex', 0)
+        .attr('role', 'button');
+      group.append('circle')
+        .attr('r', node => node.kind === 'mapping' ? 6 : 8)
+        .attr('fill', node => fill(node.kind))
+        .attr('stroke', '#fff')
+        .attr('stroke-width', 2);
+      group.append('text')
+        .attr('x', 13)
+        .attr('y', 4)
+        .attr('font-size', 12)
+        .attr('fill', '#1f2937')
+        .text(node => text(node.label || node.id).slice(0, 42));
+      group.append('title').text(node => `${node.kind}: ${node.label || node.id}`);
+      return group;
+    })
+    .call(drag)
+    .on('click', (event, node) => {
+      event.stopPropagation();
+      selectedId = selectedId === node.id ? null : node.id;
+      renderVisibility();
+    })
+    .on('dblclick', (event, node) => {
+      event.stopPropagation();
+      const toggleId = nearestHierarchyToggle(node.id);
+      if (!toggleId) return;
+      if (collapsedHierarchyIds.has(toggleId)) collapsedHierarchyIds.delete(toggleId);
+      else collapsedHierarchyIds.add(toggleId);
+      if (selectedId && isCollapsed(selectedId)) selectedId = null;
+      renderVisibility();
+    });
+
+  function updatePositions() {
+    linkSelection
+      .attr('x1', link => nodeById.get(link.source)?.x || 0)
+      .attr('y1', link => nodeById.get(link.source)?.y || 0)
+      .attr('x2', link => nodeById.get(link.target)?.x || 0)
+      .attr('y2', link => nodeById.get(link.target)?.y || 0);
+    nodeSelection.attr('transform', node => `translate(${node.x},${node.y})`);
+  }
+
+  function renderVisibility() {
+    visibleNodeIds = computeVisibleNodeIds();
+    if (selectedId && !visibleNodeIds.has(selectedId)) selectedId = null;
+    const activeNodes = new Set();
+    const activeLinks = new Set();
+    if (selectedId) {
+      activeNodes.add(selectedId);
+      (adjacency.get(selectedId) || new Set()).forEach(id => activeNodes.add(id));
+      (linksByNode.get(selectedId) || new Set()).forEach(id => activeLinks.add(id));
+    }
+    nodeSelection
+      .classed('hidden', node => !visibleNodeIds.has(node.id))
+      .classed('selected', node => node.id === selectedId)
+      .classed('active', node => Boolean(selectedId && activeNodes.has(node.id)))
+      .classed('dimmed', node => Boolean(selectedId && visibleNodeIds.has(node.id) && !activeNodes.has(node.id)));
+    linkSelection
+      .classed('hidden', link => !isLinkVisible(link))
+      .classed('active', link => Boolean(selectedId && activeLinks.has(linkKey(link))))
+      .classed('dimmed', link => Boolean(selectedId && isLinkVisible(link) && !activeLinks.has(linkKey(link))));
+  }
+
+  function expandDepth() {
+    hierarchyDepth = Math.min(maxDepth, hierarchyDepth + 1);
+    renderVisibility();
+  }
+
+  function collapseDepth() {
+    hierarchyDepth = Math.max(0, hierarchyDepth - 1);
+    renderVisibility();
+  }
+
+  section.querySelector('[data-action="reset"]')?.addEventListener('click', () => {
+    hierarchyDepth = defaultHierarchyDepth;
+    showEdges = defaultShowEdges;
+    query = '';
+    selectedId = null;
+    collapsedHierarchyIds.clear();
+    const search = section.querySelector('[data-action="search"]');
+    if (search) search.value = '';
+    const edges = section.querySelector('[data-action="edges"]');
+    if (edges) edges.checked = showEdges;
+    svgSelection.transition().duration(150).call(zoom.transform, d3.zoomIdentity);
+    renderVisibility();
+  });
+  section.querySelector('[data-action="depth-plus"]')?.addEventListener('click', expandDepth);
+  section.querySelector('[data-action="depth-minus"]')?.addEventListener('click', collapseDepth);
+  section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; renderVisibility(); });
+  section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = text(event.target.value).toLowerCase(); renderVisibility(); });
+  updatePositions();
+  renderVisibility();
 })();
 """
 
@@ -1140,8 +1371,8 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     controls = (
         '<div class="focused-graph-toolbar">'
         '<button type="button" data-action="reset">Reset</button>'
-        '<button type="button" data-action="depth-plus">+1</button>'
-        '<button type="button" data-action="depth-minus">-1</button>'
+        '<button type="button" data-action="depth-plus" aria-label="Expand hierarchy depth" title="Expand hierarchy depth">+1</button>'
+        '<button type="button" data-action="depth-minus" aria-label="Collapse hierarchy depth" title="Collapse hierarchy depth">-1</button>'
         '<label><input type="checkbox" data-action="edges" checked> Edges</label>'
         '<input type="search" data-action="search" placeholder="Search nodes" aria-label="Search focused graph nodes">'
         '</div>'
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 820034d..2f0f150 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -342,6 +342,25 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "-1" in html
     assert "Edges" in html
     assert "Search nodes" in html
+    assert "d3.zoom()" in html
+    assert "d3.drag()" in html
+    assert ".on('start', function(event) {" in html
+    assert "selectedId = node.id;\n      d3.select(this).classed('dragging', true)" not in html
+    assert "dblclick" in html
+    assert "focused-graph-layer" in html
+    assert "focused-graph-node.selected" in html
+    assert "focused-graph-node.hidden" in html
+    assert "focused-graph-link.active" in html
+    assert "focused-graph-link.dimmed" in html
+    assert "collapsedHierarchyIds" in html
+    assert "return nodeId !== rootHierarchyId && (hierarchyChildrenById.get(nodeId) || []).length ? nodeId : '';" in html
+    assert "return hierarchyNodeById.has(nodeId) ? nodeId : '';" not in html
+    assert "visibleNodeIds" in html
+    assert "expandDepth" in html
+    assert "collapseDepth" in html
+    assert "Expand hierarchy depth" in html
+    assert "Collapse hierarchy depth" in html
+    assert "d3.zoomIdentity" in html
     assert "Static focused graph fallback is available when D3 cannot run." in html
     assert "semantic_nodes" in html
     assert "code_nodes" in html

From 6089addd99a1e8e585d95fd864fe73105c88e371 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Tue, 7 Jul 2026 07:16:15 +0000
Subject: [PATCH 33/56] review: fix focused graph hierarchy layout

Keep hierarchy controls inside the focused graph viewport so double-click collapse and expand can be used after depth changes.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/common/run_report.py | 53 +++++++++++++++++++++++---
 CoderMind/tests/test_run_report.py     |  6 +++
 2 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index d383f9a..78d6703 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -952,6 +952,46 @@ def _append_context_node(nodes: list[dict[str, Any]], seen: set[str], link_id: A
     return graph_id
 
 
+def _append_hierarchy_nodes(
+    nodes: list[dict[str, Any]],
+    links: list[dict[str, Any]],
+    seen_nodes: set[str],
+    hierarchy: Any,
+) -> None:
+    if not isinstance(hierarchy, Mapping):
+        return
+    seen_links = {str(link.get("id")) for link in links if isinstance(link, Mapping) and link.get("id") not in (None, "")}
+
+    def node_id(row: Mapping[str, Any]) -> str:
+        return str(row.get("id") or row.get("link_id") or row.get("node_id") or "")
+
+    def visit(row: Any) -> str:
+        if not isinstance(row, Mapping):
+            return ""
+        row_id = node_id(row)
+        children = [child for child in _as_sequence(row.get("children")) if isinstance(child, Mapping)]
+        if row_id and children and row_id not in seen_nodes:
+            seen_nodes.add(row_id)
+            nodes.append({
+                "id": row_id,
+                "kind": "hierarchy",
+                "label": str(row.get("name") or row.get("node_id") or row_id),
+                "node_id": row.get("node_id") or row_id,
+                "state": row.get("state") or row.get("kind") or "hierarchy",
+                "type": row.get("kind") or "hierarchy",
+            })
+        for child in children:
+            child_id = visit(child)
+            if row_id in seen_nodes and child_id in seen_nodes:
+                link_id = f"hierarchy-{_slug(row_id)}-{_slug(child_id)}"
+                if link_id not in seen_links:
+                    seen_links.add(link_id)
+                    links.append({"id": link_id, "source": row_id, "target": child_id, "kind": "hierarchy", "relation": "contains"})
+        return row_id
+
+    visit(hierarchy)
+
+
 def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mapping[str, str]) -> dict[str, Any]:
     nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
     summary = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else focused_view.get("summary", {})
@@ -1012,6 +1052,7 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
     focused_graph = nodes_view.get("focused_graph") if isinstance(nodes_view.get("focused_graph"), Mapping) else {}
     hierarchy = nodes_view.get("hierarchy") or focused_graph.get("hierarchy") or {}
     default_focus = nodes_view.get("default_focus") or focused_graph.get("default_focus") or {}
+    _append_hierarchy_nodes(nodes, links, seen_nodes, hierarchy)
     return {
         "schema": "cmind.focused_graph.render.v1",
         "summary": summary,
@@ -1100,7 +1141,7 @@ def _focused_graph_runtime() -> str:
   const linksByNode = new Map(nodes.map(node => [node.id, new Set()]));
 
   function fill(kind) {
-    return kind === 'semantic' ? '#2563eb' : kind === 'code' ? '#16a34a' : kind === 'mapping' ? '#f59e0b' : '#64748b';
+    return kind === 'semantic' ? '#2563eb' : kind === 'code' ? '#16a34a' : kind === 'mapping' ? '#f59e0b' : kind === 'hierarchy' ? '#8b5cf6' : '#64748b';
   }
   function linkKey(link) {
     return text(link.id || `${link.source}-${link.target}`);
@@ -1140,11 +1181,13 @@ def _focused_graph_runtime() -> str:
   });
 
   function layout(rows) {
-    const groups = {semantic: [], mapping: [], code: [], context: []};
+    const groups = {hierarchy: [], semantic: [], mapping: [], code: [], context: []};
     rows.forEach(node => (groups[node.kind] || groups.context).push(node));
-    const x = {semantic: 150, mapping: 420, code: 690, context: 840};
+    const x = {hierarchy: 90, semantic: 240, mapping: 455, code: 690, context: 850};
+    const marginY = 36;
+    const availableY = Math.max(120, height - marginY * 2);
     Object.entries(groups).forEach(([kind, groupRows]) => {
-      const gap = Math.max(44, Math.min(78, 380 / Math.max(groupRows.length, 1)));
+      const gap = groupRows.length > 1 ? Math.min(78, availableY / (groupRows.length - 1)) : 0;
       const start = height / 2 - ((groupRows.length - 1) * gap) / 2;
       groupRows.forEach((node, index) => { node.x = x[kind] || width / 2; node.y = start + index * gap; });
     });
@@ -1172,7 +1215,6 @@ def _focused_graph_runtime() -> str:
   }
 
   function isCollapsed(nodeId) {
-    if (collapsedHierarchyIds.has(nodeId)) return true;
     return list(hierarchyAncestorsById.get(nodeId)).some(id => collapsedHierarchyIds.has(id));
   }
 
@@ -1382,6 +1424,7 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         '<span class="legend-item"><span class="legend-swatch legend-semantic"></span>Semantic</span>'
         '<span class="legend-item"><span class="legend-swatch legend-code"></span>Code</span>'
         '<span class="legend-item"><span class="legend-swatch legend-mapping"></span>Mapping</span>'
+        '<span class="legend-item"><span class="legend-swatch" style="background:#8b5cf6"></span>Hierarchy</span>'
         '<span class="legend-item"><span class="legend-swatch legend-context"></span>Context edge</span>'
         '</div>'
     )
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 2f0f150..5b7e2a2 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -352,7 +352,13 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
+    assert "Hierarchy" in html
+    assert '"kind": "hierarchy"' in html
+    assert "const groups = {hierarchy: [], semantic: [], mapping: [], code: [], context: []};" in html
+    assert "const availableY = Math.max(120, height - marginY * 2);" in html
     assert "collapsedHierarchyIds" in html
+    assert "return list(hierarchyAncestorsById.get(nodeId)).some(id => collapsedHierarchyIds.has(id));" in html
+    assert "if (collapsedHierarchyIds.has(nodeId)) return true;" not in html
     assert "return nodeId !== rootHierarchyId && (hierarchyChildrenById.get(nodeId) || []).length ? nodeId : '';" in html
     assert "return hierarchyNodeById.has(nodeId) ? nodeId : '';" not in html
     assert "visibleNodeIds" in html

From f245616a1c95eac2c012f99737984194c6205a25 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Tue, 7 Jul 2026 09:30:27 +0000
Subject: [PATCH 34/56] rpg_edit: Remove the low-density static focused graph
 evidence block f

---
 CoderMind/scripts/common/run_report.py | 119 ++++++-------------------
 CoderMind/tests/test_run_report.py     |  29 +++---
 2 files changed, 43 insertions(+), 105 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 78d6703..6a6b4bb 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -414,11 +414,10 @@ def _render_page(
 <div class=\"meta\"><span>Command: <strong>{_h(command)}</strong></span><span>Generated: {_h(generated_at)}</span>{status_html}</div>
 </header>
 {_render_summary_cards(summary_cards)}
-{_render_timeline(stages)}
+{_render_timeline(stages, verification)}
 {_render_safety_boundary(user_decisions)}
 {_render_focused_graph(focused_view, code_file_anchors)}
 {_render_code_deltas(code_deltas, code_delta_anchors)}
-{_render_verification(verification)}
 {_render_artifacts(artifacts)}
 {_render_evidence(evidence)}
 </main>
@@ -450,40 +449,31 @@ def _render_summary_cards(cards: list[dict[str, Any]]) -> str:
     return f"<section><h2>Summary</h2>{body}</section>"
 
 
-def _render_timeline(stages: list[dict[str, Any]]) -> str:
-    if not stages:
-        body = "<p class=\"empty\">No stages recorded.</p>"
-    else:
-        items = []
-        for stage in stages:
-            duration = stage.get("duration")
-            duration_text = f"<span class=\"badge\">{_h(duration)}s</span>" if duration not in (None, "") else ""
-            items.append(
-                "<li>"
-                f"<div class=\"stage-head\"><strong>{_h(stage.get('name', 'stage'))}</strong>"
-                f"<span class=\"badge\">{_h(stage.get('status', 'recorded'))}</span>{duration_text}</div>"
-                f"<div class=\"reason\">{_h(stage.get('reason', ''))}</div>"
-                "</li>"
-            )
+def _render_timeline(stages: list[dict[str, Any]], checks: list[dict[str, Any]]) -> str:
+    items = []
+    for stage in stages:
+        duration = stage.get("duration")
+        duration_text = f"<span class=\"badge\">{_h(duration)}s</span>" if duration not in (None, "") else ""
+        items.append(
+            "<li>"
+            f"<div class=\"stage-head\"><strong>{_h(stage.get('name', 'stage'))}</strong>"
+            f"<span class=\"badge\">{_h(stage.get('status', 'recorded'))}</span>{duration_text}</div>"
+            f"<div class=\"reason\">{_h(stage.get('reason', ''))}</div>"
+            "</li>"
+        )
+    for check in checks:
+        items.append(
+            "<li>"
+            f"<div class=\"stage-head\"><strong>{_h(check.get('name') or 'verification')}</strong>"
+            f"<span class=\"badge\">{_h(check.get('status', ''))}</span></div>"
+            f"<div class=\"reason\">{_h(check.get('detail', ''))}</div>"
+            "</li>"
+        )
+    if items:
         body = '<ol class="timeline">' + "".join(items) + "</ol>"
-    return f"<section><h2>Stage timeline</h2>{body}</section>"
-
-
-def _render_verification(checks: list[dict[str, Any]]) -> str:
-    if not checks:
-        body = "<p class=\"empty\">No verification status recorded.</p>"
     else:
-        rows = []
-        for check in checks:
-            rows.append(
-                "<tr>"
-                f"<td>{_h(check.get('name') or 'verification')}</td>"
-                f"<td>{_h(check.get('status', ''))}</td>"
-                f"<td>{_h(check.get('detail', ''))}</td>"
-                "</tr>"
-            )
-        body = "<table><thead><tr><th>Check</th><th>Status</th><th>Detail</th></tr></thead><tbody>" + "".join(rows) + "</tbody></table>"
-    return f"<section><h2>Verification status</h2>{body}</section>"
+        body = "<p class=\"empty\">No stages recorded.</p>"
+    return f"<section><h2>Stage timeline</h2>{body}</section>"
 
 
 def _render_safety_boundary(decisions: list[dict[str, Any]]) -> str:
@@ -837,37 +827,6 @@ def _mapping_card(mapping: Mapping[str, Any]) -> str:
     )
 
 
-def _edge_endpoint_html(node_id: Any, link_id: Any) -> str:
-    if link_id not in (None, ""):
-        return f"<a href=\"#{_h_attr(link_id)}\"><code>{_h(node_id)}</code></a>"
-    return f"<code>{_h(node_id)}</code>"
-
-
-def _nodes_view_edges_html(edges: Sequence[Mapping[str, Any]]) -> str:
-    edge_rows = []
-    for edge in edges:
-        source = _edge_endpoint_html(edge.get("source_node_id"), edge.get("source_link_id"))
-        target = _edge_endpoint_html(edge.get("target_node_id"), edge.get("target_link_id"))
-        edge_rows.append(
-            "<tr>"
-            f"<td>{source}</td>"
-            f"<td>{target}</td>"
-            f"<td>{_h(edge.get('relation', ''))}</td>"
-            f"<td>{_h(edge.get('direction', ''))}</td>"
-            f"<td>{_h(edge.get('path', ''))}</td>"
-            f"<td>{_h(edge.get('reason', ''))}</td>"
-            "</tr>"
-        )
-    if not edge_rows:
-        return ""
-    return (
-        "<h3>One-hop context</h3>"
-        "<table><thead><tr><th>Source</th><th>Target</th><th>Relation</th><th>Direction</th><th>Path</th><th>Reason</th></tr></thead><tbody>"
-        + "".join(edge_rows)
-        + "</tbody></table>"
-    )
-
-
 def _inline_d3() -> str:
     try:
         return _D3_ASSET.read_text(encoding="utf-8").strip()
@@ -1069,32 +1028,6 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
     }
 
 
-def _focused_graph_evidence(nodes_view: Mapping[str, Any], file_anchors: Mapping[str, str]) -> str:
-    semantic_cards = [
-        _semantic_card(node, file_anchors)
-        for node in _as_sequence(nodes_view.get("semantic_nodes"))
-        if isinstance(node, Mapping)
-    ]
-    code_cards = [
-        _code_card(node, file_anchors)
-        for node in _as_sequence(nodes_view.get("code_nodes"))
-        if isinstance(node, Mapping)
-    ]
-    mapping_cards = [
-        _mapping_card(mapping)
-        for mapping in _as_sequence(nodes_view.get("mappings"))
-        if isinstance(mapping, Mapping)
-    ]
-    edge_rows = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
-    body = "<h3>Focused graph evidence</h3>"
-    if semantic_cards or code_cards or mapping_cards:
-        body += '<div class="focus-map">' + "".join(semantic_cards + code_cards + mapping_cards) + "</div>"
-    else:
-        body += '<p class="empty">No focused graph evidence rows recorded.</p>'
-    body += _nodes_view_edges_html(edge_rows)
-    return body
-
-
 def _focused_graph_runtime() -> str:
     return r"""
 (function(){
@@ -1436,7 +1369,6 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="480"></svg>'
         f'<div class="focused-graph-fallback" data-focused-graph-fallback{fallback_hidden}>Static focused graph fallback is available when D3 cannot run.{d3_missing_note}</div>'
         '</div>'
-        f"{_focused_graph_evidence(nodes_view, file_anchors)}"
         f"<details><summary>Inspector JSON</summary><pre>{_h(inspector)}</pre></details>"
         f"{scripts}"
         '</section>'
@@ -1470,7 +1402,6 @@ def _legacy_render_focused_nodes_map(focused_view: dict[str, Any], file_anchors:
         for mapping in _as_sequence(nodes_view.get("mappings"))
         if isinstance(mapping, Mapping)
     ]
-    edge_rows = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
     hidden_html = _hidden_context_html(nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else {})
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings")) if isinstance(warning, Mapping)]
     warnings_html = f"<h3>Warnings</h3>{_chain_warning_html(warnings)}" if warnings else ""
@@ -1479,7 +1410,7 @@ def _legacy_render_focused_nodes_map(focused_view: dict[str, Any], file_anchors:
         body += '<div class="focus-map">' + "".join(semantic_cards + code_cards + mapping_cards) + "</div>"
     else:
         body += '<p class="empty">No focused nodes map rows recorded.</p>'
-    body += _nodes_view_edges_html(edge_rows) + hidden_html + warnings_html + _focused_graph_metadata(focused_view)
+    body += hidden_html + warnings_html + _focused_graph_metadata(focused_view)
     return f"<section><h2>Focused nodes map</h2>{body}</section>"
 
 
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 5b7e2a2..2f12d8e 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -75,7 +75,6 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
         "Safety boundary",
         "Focused graph",
         "What changed?",
-        "Verification status",
         "Artifact links",
         "Evidence JSON",
     ]
@@ -84,7 +83,8 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
     assert "Summary" in html
     assert "Stage timeline" in html
     assert "Safety boundary" in html
-    assert "Verification status" in html
+    assert "Verification status" not in html
+    assert "pytest" in html
     assert "Artifact links" in html
     assert "Evidence JSON" in html
     assert "Before state" in html
@@ -325,9 +325,9 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "Why these nodes?" not in html
     assert "Focused impact view" not in html
     assert "What changed?" in html
-    assert "Focused graph evidence" in html
-    assert "focus-map" in html
-    assert "One-hop context" in html
+    assert "Focused graph evidence" not in html
+    assert '<div class="focus-map">' not in html
+    assert "One-hop context" not in html
     assert "data-focused-graph-json" in html
     assert "focused-graph-svg" in html
     assert "https://d3js.org v7.9.0" in html
@@ -378,10 +378,11 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "Root / Feature &lt;unsafe&gt;" in html
     assert "NodeSymbol &lt;unsafe&gt;" in html
     assert "function&lt;script&gt;" in html
-    assert "Lines: 10-12" in html
-    assert "Mapped code:" in html
-    assert "Mapped code: <span class=\"empty\">missing mapping</span>" in html
-    assert "href=\"#diff-a.py\"" in html
+    assert '"kind": "context"' in html
+    assert '"relation": "caller"' in html
+    assert '"href": "#diff-a.py"' in html
+    assert "Lines: 10-12" not in html
+    assert "Mapped code:" not in html
     assert "id=\"diff-a.py\"" in html
     assert html.count("<summary>Inspector JSON</summary>") == 1
     assert "mapped" in html
@@ -529,8 +530,14 @@ def test_write_command_report_infers_artifact_status_and_preserves_verification_
     assert "<td>missing_json</td>" in html
     assert html.count("<td>available</td>") == 1
     assert html.count("<td>missing</td>") == 1
-    assert "<td>from message</td>" in html
-    assert "<td>from reason</td>" in html
+    assert "Verification status" not in html
+    assert "Stage timeline" in html
+    assert "<strong>message</strong>" in html
+    assert "<strong>reason</strong>" in html
+    assert "from message" in html
+    assert "from reason" in html
+    assert "<td>from message</td>" not in html
+    assert "<td>from reason</td>" not in html
 
 
 def test_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:

From 81692837cefbcf612328984c92d2ecf0e50c7a85 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 03:18:24 +0000
Subject: [PATCH 35/56] decoder_lang: implement Python backend test hooks

Implement Python backend environment and pytest result hooks so smoke checks no longer flag protocol methods as stubs, and stabilize the C++ prompt test's toolchain assumptions.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 .../scripts/decoder_lang/python_backend.py    | 112 ++++++++++----
 .../decoder_lang/tests/test_python_backend.py | 145 +++++++++++++++---
 CoderMind/tests/test_code_gen_multilingual.py |   9 ++
 3 files changed, 215 insertions(+), 51 deletions(-)

diff --git a/CoderMind/scripts/decoder_lang/python_backend.py b/CoderMind/scripts/decoder_lang/python_backend.py
index 06384dd..17717cb 100644
--- a/CoderMind/scripts/decoder_lang/python_backend.py
+++ b/CoderMind/scripts/decoder_lang/python_backend.py
@@ -14,6 +14,7 @@
 import ast
 import keyword
 import logging
+import sys
 from pathlib import Path
 from typing import Any
 
@@ -22,7 +23,7 @@
 from .prompt_hints import PromptHints
 from .project_tasks import ProjectTaskContext, ProjectTaskTemplates
 from .unit_kind import classify_unit_kind
-from .test_result import EnvHandle, TestRunResult
+from .test_result import EnvHandle, TestFailure, TestRunResult, ran_no_tests
 
 logger = logging.getLogger(__name__)
 
@@ -419,23 +420,34 @@ def _source_for_node(source: str, node: ast.AST) -> str:
             return ""
 
     # ------------------------------------------------------------------
-    # 3. Build / test environment — not wired into the decoder yet
+    # 3. Build / test environment
     # ------------------------------------------------------------------
 
     def detect_env(self, repo_root: Path) -> EnvHandle | None:
-        """Return an existing Python test environment when supported."""
-        raise NotImplementedError(
-            "PythonBackend.detect_env is not wired into the decoder; "
-            "callers should keep using code_gen.test_runner.get_dev_python "
-            "for now.",
+        """Return the existing managed Python test environment, if present."""
+        from code_gen.test_runner import get_dev_python, get_dev_venv_path
+
+        root = repo_root.resolve()
+        py = get_dev_python(root)
+        if py is None:
+            return None
+        return EnvHandle(
+            project_root=root,
+            runtime_executable=py,
+            extra={"venv": str(get_dev_venv_path(root))},
         )
 
     def ensure_env(self, repo_root: Path) -> EnvHandle:
-        """Always available on a host that's already running Python
-        (the decoder itself), so this never raises
-        :class:`ToolchainUnavailable` once implemented."""
-        raise NotImplementedError(
-            "PythonBackend.ensure_env is not wired into the decoder.",
+        """Create or reuse the managed Python test environment."""
+        from code_gen.test_runner import ensure_dev_venv, get_dev_python, get_dev_venv_path
+
+        root = repo_root.resolve()
+        ensure_dev_venv(root)
+        py = get_dev_python(root) or sys.executable
+        return EnvHandle(
+            project_root=root,
+            runtime_executable=py,
+            extra={"venv": str(get_dev_venv_path(root))},
         )
 
     def test_command(
@@ -443,33 +455,77 @@ def test_command(
         env: EnvHandle,
         selectors: list[str] | None = None,
     ) -> list[str]:
-        """Return the command used to run Python tests when supported."""
-        raise NotImplementedError(
-            "PythonBackend.test_command is not wired into the decoder; "
-            "callers should keep using code_gen.batch_prompts."
-            "build_batch_pytest_cmd for now.",
-        )
+        """Return the pytest command for a Python environment."""
+        python = env.runtime_executable or sys.executable
+        cmd = [python, "-m", "pytest"]
+        if selectors:
+            cmd.extend(["-k", " or ".join(selectors)])
+        return cmd
 
     def install_deps_command(
         self,
         env: EnvHandle,
         deps: list[str],
     ) -> list[str] | None:
-        """Return a dependency-install command when supported."""
-        raise NotImplementedError(
-            "PythonBackend.install_deps_command is not wired into the decoder.",
-        )
+        """Return a pip/uv install command for missing Python deps."""
+        if not deps:
+            return None
+        from code_gen.test_runner import _build_pip_cmd
+
+        return _build_pip_cmd(deps, env.project_root)
 
     # ------------------------------------------------------------------
-    # 4. Test-output parsing — not wired into the decoder yet
+    # 4. Test-output parsing
     # ------------------------------------------------------------------
 
     def parse_test_output(self, raw: str, exit_code: int) -> TestRunResult:
-        """Parse native Python test output when backend-driven tests run."""
-        raise NotImplementedError(
-            "PythonBackend.parse_test_output is not wired into the decoder; "
-            "callers should keep using code_gen.test_output_parser."
-            "analyze_test_output for now.",
+        """Parse pytest output into the backend-neutral result shape."""
+        from code_gen.test_output_parser import analyze_test_output
+
+        analysis = analyze_test_output(raw)
+        observed = analysis.passed + analysis.failed + analysis.errors
+        failures: list[TestFailure] = []
+        if (analysis.failed or analysis.errors) and analysis.failure_lines:
+            test_id = analysis.failing_test_files[0] if analysis.failing_test_files else "pytest"
+            failures.append(TestFailure(
+                test_id=test_id,
+                short_message=analysis.failure_lines.splitlines()[0],
+                long_message=analysis.failure_lines,
+                file_path=analysis.failing_test_files[0] if analysis.failing_test_files else None,
+            ))
+
+        if ran_no_tests(exit_code, raw, observed_tests=observed or None):
+            status = "errored"
+            error_count = analysis.errors or 1
+        elif exit_code == 0:
+            status = "passed"
+            error_count = analysis.errors
+        else:
+            status = "failed"
+            error_count = analysis.errors
+
+        return TestRunResult(
+            status=status,
+            exit_code=exit_code,
+            passed_count=analysis.passed,
+            failed_count=analysis.failed,
+            error_count=error_count,
+            skipped_count=analysis.skipped,
+            duration_sec=analysis.duration,
+            failures=failures,
+            raw_output=raw,
+            extra={
+                "tool": "pytest",
+                "failure_type": analysis.failure_type,
+                "env_sub_type": analysis.env_sub_type,
+                "env_fix_target": analysis.env_fix_target,
+                "env_instruction": analysis.env_instruction,
+                "env_details": analysis.env_details,
+                "missing_names": analysis.missing_names,
+                "missing_modules": analysis.missing_modules,
+                "failing_test_files": analysis.failing_test_files,
+                "has_tests_run": analysis.has_tests_run,
+            },
         )
 
     # ------------------------------------------------------------------
diff --git a/CoderMind/scripts/decoder_lang/tests/test_python_backend.py b/CoderMind/scripts/decoder_lang/tests/test_python_backend.py
index 8e57001..d81bb73 100644
--- a/CoderMind/scripts/decoder_lang/tests/test_python_backend.py
+++ b/CoderMind/scripts/decoder_lang/tests/test_python_backend.py
@@ -1,15 +1,16 @@
 """Tests for the decoder backend registry and Python backend contract.
 
 These tests focus on invariants relied on by code paths that already
-route through :mod:`decoder_lang`. Unsupported methods are asserted to
-raise ``NotImplementedError`` so accidental partial implementations are
-visible.
+route through :mod:`decoder_lang`, including Python-specific environment
+and pytest result handling.
 """
 from __future__ import annotations
 
 import sys
+import types
 import unittest
 from pathlib import Path
+from unittest.mock import Mock, patch
 
 # Make ``scripts/`` importable when these tests are run directly.
 _SCRIPTS_DIR = Path(__file__).resolve().parents[2]
@@ -200,35 +201,133 @@ def test_syntax_check(self) -> None:
         self.assertIn("SyntaxError", err or "")
 
 
-class StubbedMethodsTests(unittest.TestCase):
-    """Unsupported methods must raise instead of returning bad data."""
+class BackendRuntimeTests(unittest.TestCase):
+    """Python backend build/test environment and pytest parsing."""
 
     def setUp(self) -> None:
         self.backend = get_backend("python")
 
-    def test_detect_env_stub(self) -> None:
-        with self.assertRaises(NotImplementedError):
-            self.backend.detect_env(Path("."))
+    def _fake_test_runner(
+        self,
+        *,
+        python: str | None = "/repo/.cmind-dev-venv/bin/python",
+        venv: Path = Path("/repo/.cmind-dev-venv"),
+        pip_cmd: list[str] | None = None,
+    ) -> types.ModuleType:
+        runner = types.ModuleType("code_gen.test_runner")
+        runner.get_dev_python = Mock(return_value=python)
+        runner.get_dev_venv_path = Mock(return_value=venv)
+        runner.ensure_dev_venv = Mock(return_value=(python is None, venv))
+        runner._build_pip_cmd = Mock(return_value=pip_cmd or ["pip", "install"])
+        return runner
+
+    def test_detect_env_returns_none_without_existing_dev_python(self) -> None:
+        repo_root = Path("/repo")
+        runner = self._fake_test_runner(python=None)
+
+        with patch.dict(sys.modules, {"code_gen.test_runner": runner}):
+            self.assertIsNone(self.backend.detect_env(repo_root))
+
+        runner.get_dev_python.assert_called_once_with(repo_root.resolve())
+        runner.get_dev_venv_path.assert_not_called()
+
+    def test_detect_env_returns_existing_dev_python_handle(self) -> None:
+        repo_root = Path("/repo")
+        runner = self._fake_test_runner()
+
+        with patch.dict(sys.modules, {"code_gen.test_runner": runner}):
+            env = self.backend.detect_env(repo_root)
+
+        self.assertIsNotNone(env)
+        assert env is not None
+        self.assertEqual(env.project_root, repo_root.resolve())
+        self.assertEqual(env.runtime_executable, "/repo/.cmind-dev-venv/bin/python")
+        self.assertEqual(env.extra["venv"], "/repo/.cmind-dev-venv")
+
+    def test_ensure_env_creates_or_reuses_dev_python_handle(self) -> None:
+        repo_root = Path("/repo")
+        runner = self._fake_test_runner()
+
+        with patch.dict(sys.modules, {"code_gen.test_runner": runner}):
+            env = self.backend.ensure_env(repo_root)
+
+        runner.ensure_dev_venv.assert_called_once_with(repo_root.resolve())
+        runner.get_dev_python.assert_called_once_with(repo_root.resolve())
+        self.assertEqual(env.project_root, repo_root.resolve())
+        self.assertEqual(env.runtime_executable, "/repo/.cmind-dev-venv/bin/python")
+        self.assertEqual(env.extra["venv"], "/repo/.cmind-dev-venv")
+
+    def test_test_command_uses_runtime_and_selectors(self) -> None:
+        from decoder_lang.test_result import EnvHandle
 
-    def test_ensure_env_stub(self) -> None:
-        with self.assertRaises(NotImplementedError):
-            self.backend.ensure_env(Path("."))
+        env = EnvHandle(project_root=Path("/repo"), runtime_executable="/venv/bin/python")
+        self.assertEqual(
+            self.backend.test_command(env, selectors=["AlphaTests", "test_beta"]),
+            ["/venv/bin/python", "-m", "pytest", "-k", "AlphaTests or test_beta"],
+        )
 
-    def test_test_command_stub(self) -> None:
+    def test_test_command_falls_back_to_current_python(self) -> None:
         from decoder_lang.test_result import EnvHandle
-        with self.assertRaises(NotImplementedError):
-            self.backend.test_command(EnvHandle(project_root=Path(".")))
 
-    def test_install_deps_command_stub(self) -> None:
+        env = EnvHandle(project_root=Path("/repo"))
+        self.assertEqual(self.backend.test_command(env), [sys.executable, "-m", "pytest"])
+
+    def test_install_deps_command_returns_none_for_no_deps(self) -> None:
         from decoder_lang.test_result import EnvHandle
-        with self.assertRaises(NotImplementedError):
-            self.backend.install_deps_command(
-                EnvHandle(project_root=Path(".")), deps=["x"],
-            )
-
-    def test_parse_test_output_stub(self) -> None:
-        with self.assertRaises(NotImplementedError):
-            self.backend.parse_test_output("foo", 0)
+
+        env = EnvHandle(project_root=Path("/repo"))
+        self.assertIsNone(self.backend.install_deps_command(env, deps=[]))
+
+    def test_install_deps_command_delegates_to_test_runner(self) -> None:
+        from decoder_lang.test_result import EnvHandle
+
+        repo_root = Path("/repo")
+        runner = self._fake_test_runner(pip_cmd=["uv", "pip", "install", "requests"])
+        env = EnvHandle(project_root=repo_root)
+
+        with patch.dict(sys.modules, {"code_gen.test_runner": runner}):
+            cmd = self.backend.install_deps_command(env, deps=["requests"])
+
+        self.assertEqual(cmd, ["uv", "pip", "install", "requests"])
+        runner._build_pip_cmd.assert_called_once_with(["requests"], repo_root)
+
+    def test_parse_test_output_reports_passing_pytest_output(self) -> None:
+        output = "============================== 3 passed in 0.12s =============================="
+
+        result = self.backend.parse_test_output(output, 0)
+
+        self.assertEqual(result.status, "passed")
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.passed_count, 3)
+        self.assertEqual(result.failed_count, 0)
+        self.assertEqual(result.error_count, 0)
+        self.assertEqual(result.duration_sec, 0.12)
+        self.assertTrue(result.extra["has_tests_run"])
+
+    def test_parse_test_output_reports_failing_pytest_output(self) -> None:
+        output = (
+            "FAILED tests/test_sample.py::test_bad - AssertionError: no\n"
+            "E   AssertionError: no\n"
+            "========================= 1 failed, 2 passed in 0.50s ========================="
+        )
+
+        result = self.backend.parse_test_output(output, 1)
+
+        self.assertEqual(result.status, "failed")
+        self.assertEqual(result.passed_count, 2)
+        self.assertEqual(result.failed_count, 1)
+        self.assertEqual(result.duration_sec, 0.50)
+        self.assertEqual(result.failures[0].test_id, "tests/test_sample.py")
+        self.assertEqual(result.failures[0].file_path, "tests/test_sample.py")
+        self.assertIn("AssertionError", result.failures[0].long_message)
+
+    def test_parse_test_output_flags_empty_success_as_errored(self) -> None:
+        result = self.backend.parse_test_output("", 0)
+
+        self.assertEqual(result.status, "errored")
+        self.assertEqual(result.error_count, 1)
+        self.assertEqual(result.passed_count, 0)
+        self.assertFalse(result.extra["has_tests_run"])
 
 
 class PromptHintsTests(unittest.TestCase):
diff --git a/CoderMind/tests/test_code_gen_multilingual.py b/CoderMind/tests/test_code_gen_multilingual.py
index ce62b59..47dac18 100644
--- a/CoderMind/tests/test_code_gen_multilingual.py
+++ b/CoderMind/tests/test_code_gen_multilingual.py
@@ -113,6 +113,15 @@ def test_cpp_codegen_prompt_aligns_cmake_command_with_post_verify(monkeypatch, t
     (tmp_path / "CMakeLists.txt").write_text("cmake_minimum_required(VERSION 3.16)\n")
     task = _task("src/tasklite_cli/task.cpp")
 
+    def fake_which(name: str) -> str | None:
+        return {
+            "c++": "/usr/bin/c++",
+            "cmake": "/usr/bin/cmake",
+            "ctest": "/usr/bin/ctest",
+        }.get(name)
+
+    monkeypatch.setattr("decoder_lang.cpp_backend.shutil.which", fake_which)
+
     prompt = batch_prompts.build_tdd_prompt(_state(task), task, tmp_path)
 
     assert "cmake -S . -B build" in prompt

From 17c9111b85ff62eb9d02f3706f8bf00653298bd8 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 03:19:01 +0000
Subject: [PATCH 36/56] rpg_edit: rework focused graph visualization

Align the focused graph report with the RPG visualizer interaction model so focused paths expand by default, collapsed context remains available, semantic and syntax edges render distinctly, and warnings move below the graph.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/common/run_report.py | 736 +++++++++++++++----------
 CoderMind/scripts/rpg_edit/review.py   | 396 ++++++++++---
 2 files changed, 765 insertions(+), 367 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 6a6b4bb..36bc287 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -383,27 +383,34 @@ def _render_page(
 .focused-graph-toolbar {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; }}
 .focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid var(--line); border-radius:8px; background:#fff; color:var(--text); padding:6px 10px; font:inherit; }}
 .focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); }}
-.focused-graph-stage {{ border:1px solid var(--line); border-radius:12px; background:#fbfdff; min-height:480px; position:relative; overflow:hidden; }}
-.focused-graph-svg {{ display:block; width:100%; height:480px; cursor:grab; touch-action:none; }}
+.focused-graph-stage {{ border:1px solid var(--line); border-radius:12px; background:#fbfdff; min-height:520px; position:relative; overflow:hidden; }}
+.focused-graph-svg {{ display:block; width:100%; height:520px; cursor:grab; touch-action:none; }}
 .focused-graph-svg:active {{ cursor:grabbing; }}
-.focused-graph-link {{ transition:opacity .15s ease, stroke-width .15s ease; }}
-.focused-graph-link.active {{ opacity:1; stroke:#0f172a; stroke-width:2.6; }}
+.focused-graph-tree-link {{ fill:none; stroke:#cbd5e1; stroke-width:1.4; }}
+.focused-graph-link {{ fill:none; opacity:.78; transition:opacity .15s ease, stroke-width .15s ease; }}
+.focused-graph-link.active {{ opacity:1; stroke-width:2.8; }}
 .focused-graph-link.dimmed {{ opacity:.14; }}
 .focused-graph-link.hidden {{ display:none; }}
+.focused-graph-link.edge-semantic {{ stroke:#7c3aed; }}
+.focused-graph-link.edge-dependency {{ stroke:#ea580c; }}
+.focused-graph-link.relation-invokes, .focused-graph-link.relation-caller, .focused-graph-link.relation-callee {{ stroke:#16a34a; }}
+.focused-graph-link.relation-imports, .focused-graph-link.relation-import {{ stroke:#ea580c; }}
+.focused-graph-link.relation-inherits, .focused-graph-link.relation-inheritance {{ stroke:#9333ea; }}
+.focused-graph-link.relation-references, .focused-graph-link.relation-reference {{ stroke:#2563eb; }}
+.focused-graph-link.source-dep-graph {{ stroke-dasharray:5 3; }}
 .focused-graph-node {{ cursor:pointer; transition:opacity .15s ease; }}
-.focused-graph-node circle {{ transition:stroke .15s ease, stroke-width .15s ease; }}
-.focused-graph-node.selected circle, .focused-graph-node.active circle {{ stroke:#0f172a; stroke-width:3; }}
-.focused-graph-node.dragging {{ cursor:grabbing; }}
+.focused-graph-node circle {{ fill:#2563eb; stroke:#fff; stroke-width:2; transition:stroke .15s ease, stroke-width .15s ease; }}
+.focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle {{ stroke:#0f172a; stroke-width:3; }}
+.focused-graph-node.search-match circle {{ stroke:#f59e0b; stroke-width:3; }}
 .focused-graph-node.dimmed {{ opacity:.18; }}
 .focused-graph-node.hidden {{ display:none; }}
 .focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed var(--line); border-radius:10px; background:#fff; color:var(--muted); }}
 .focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; }}
 .legend-item {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); font-size:13px; }}
 .legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid var(--line); }}
-.legend-semantic {{ background:#2563eb; }}
-.legend-code {{ background:#16a34a; }}
-.legend-mapping {{ background:#f59e0b; }}
-.legend-context {{ background:#64748b; }}
+.legend-node {{ background:#2563eb; }}
+.legend-semantic-edge {{ background:#7c3aed; }}
+.legend-dependency-edge {{ background:#ea580c; }}
 @media (max-width:720px) {{ main {{ padding:22px 12px 36px; }} .focus-map {{ grid-template-columns:1fr; }} table {{ min-width:560px; }} }}
 </style>
 </head>
@@ -845,12 +852,42 @@ def _json_for_script(value: Any) -> str:
     )
 
 
+def _mapped_code_label(row: Mapping[str, Any]) -> str:
+    path = row.get("mapped_code_path")
+    symbol = row.get("mapped_code_symbol")
+    first = next((item for item in _as_sequence(row.get("mapped_code")) if isinstance(item, Mapping)), None)
+    if first:
+        path = path or first.get("path")
+        symbol = symbol or first.get("symbol") or first.get("name")
+    if not path:
+        paths = _as_sequence(row.get("mapped_code_paths"))
+        path = paths[0] if paths else None
+    if not symbol:
+        symbols = _as_sequence(row.get("mapped_code_symbols"))
+        symbol = symbols[0] if symbols else None
+    detail = " · ".join(str(item) for item in (path, symbol) if item not in (None, ""))
+    if not detail:
+        return ""
+    count = row.get("mapped_code_count")
+    try:
+        count_int = int(count)
+    except (TypeError, ValueError):
+        count_int = 0
+    suffix = f" +{count_int - 1}" if count_int > 1 else ""
+    return f"{detail}{suffix}"
+
+
 def _graph_label(row: Mapping[str, Any], fallback: Any) -> str:
-    for key in ("name", "symbol", "label", "path", "node_id", "dep_node_id", "id"):
+    base = ""
+    for key in ("feature_name", "name", "symbol", "label", "path", "node_id", "dep_node_id", "id"):
         value = row.get(key)
         if value not in (None, ""):
-            return str(value)
-    return str(fallback or "node")
+            base = str(value)
+            break
+    if not base:
+        base = str(fallback or "node")
+    mapped_code = _mapped_code_label(row)
+    return f"{base} — {mapped_code}" if mapped_code else base
 
 
 def _graph_diff_ref(row: Mapping[str, Any], file_anchors: Mapping[str, str]) -> dict[str, str]:
@@ -893,7 +930,23 @@ def _append_graph_node(nodes: list[dict[str, Any]], seen: set[str], row: Mapping
         "node_id": row.get("node_id") or row.get("dep_node_id"),
         "state": row.get("state") or row.get("status") or row.get("mapping_status"),
     }
-    for key in ("path", "type", "node_type", "source", "mapping_status", "locate_status", "breadcrumb_path"):
+    for key in (
+        "path",
+        "feature_path",
+        "feature_name",
+        "type",
+        "node_type",
+        "source",
+        "mapping_status",
+        "locate_status",
+        "breadcrumb_path",
+        "mapped_code",
+        "mapped_code_path",
+        "mapped_code_paths",
+        "mapped_code_symbol",
+        "mapped_code_symbols",
+        "mapped_code_count",
+    ):
         if row.get(key) not in (None, ""):
             payload[key] = row.get(key)
     diff_ref = _graph_diff_ref(row, file_anchors)
@@ -928,18 +981,33 @@ def visit(row: Any) -> str:
         if not isinstance(row, Mapping):
             return ""
         row_id = node_id(row)
-        children = [child for child in _as_sequence(row.get("children")) if isinstance(child, Mapping)]
-        if row_id and children and row_id not in seen_nodes:
+        if row_id and row_id not in seen_nodes:
             seen_nodes.add(row_id)
-            nodes.append({
+            payload = {
                 "id": row_id,
-                "kind": "hierarchy",
-                "label": str(row.get("name") or row.get("node_id") or row_id),
+                "kind": row.get("kind") or "feature",
+                "label": _graph_label(row, row.get("node_id") or row_id),
                 "node_id": row.get("node_id") or row_id,
                 "state": row.get("state") or row.get("kind") or "hierarchy",
                 "type": row.get("kind") or "hierarchy",
-            })
-        for child in children:
+            }
+            for key in (
+                "feature_name",
+                "feature_path",
+                "path",
+                "node_type",
+                "mapping_status",
+                "mapped_code",
+                "mapped_code_path",
+                "mapped_code_paths",
+                "mapped_code_symbol",
+                "mapped_code_symbols",
+                "mapped_code_count",
+            ):
+                if row.get(key) not in (None, ""):
+                    payload[key] = row.get(key)
+            nodes.append(payload)
+        for child in [child for child in _as_sequence(row.get("children")) if isinstance(child, Mapping)]:
             child_id = visit(child)
             if row_id in seen_nodes and child_id in seen_nodes:
                 link_id = f"hierarchy-{_slug(row_id)}-{_slug(child_id)}"
@@ -960,63 +1028,151 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
     context_edges = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
     hidden_counts = nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else focused_view.get("hidden_counts", {})
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings")) if isinstance(warning, Mapping)]
+    focused_graph = nodes_view.get("focused_graph") if isinstance(nodes_view.get("focused_graph"), Mapping) else {}
+    hierarchy = nodes_view.get("hierarchy") or focused_graph.get("hierarchy") or {}
+    default_focus = nodes_view.get("default_focus") or focused_graph.get("default_focus") or {}
+
+    if not isinstance(hierarchy, Mapping) or not hierarchy or (semantic_nodes and not _as_sequence(hierarchy.get("children"))):
+        hierarchy = {
+            "id": "focused-graph-root",
+            "name": "Focused graph",
+            "kind": "root",
+            "children": [
+                {
+                    "id": _graph_node_id(node, "feature"),
+                    "node_id": node.get("node_id"),
+                    "name": node.get("name") or node.get("symbol") or node.get("node_id") or "feature",
+                    "kind": "feature",
+                    "feature_name": node.get("name") or node.get("symbol") or node.get("node_id") or "feature",
+                    "feature_path": node.get("feature_path") or node.get("breadcrumb_path") or node.get("path"),
+                    "mapped_code": node.get("mapped_code"),
+                    "mapped_code_node_ids": node.get("mapped_code_node_ids"),
+                    "mapped_code_link_ids": node.get("mapped_code_link_ids"),
+                    "mapped_code_path": node.get("mapped_code_path"),
+                    "mapped_code_paths": node.get("mapped_code_paths"),
+                    "mapped_code_symbol": node.get("mapped_code_symbol"),
+                    "mapped_code_symbols": node.get("mapped_code_symbols"),
+                    "mapped_code_count": node.get("mapped_code_count"),
+                }
+                for node in semantic_nodes
+            ],
+        }
+
     nodes: list[dict[str, Any]] = []
+    links: list[dict[str, Any]] = []
     seen_nodes: set[str] = set()
+    _append_hierarchy_nodes(nodes, links, seen_nodes, hierarchy)
+
     rpg_links: dict[str, str] = {}
     code_links: dict[str, str] = {}
+    node_aliases: dict[str, list[str]] = {}
+
+    def add_alias(alias: Any, target: Any) -> None:
+        if alias in (None, "") or target in (None, ""):
+            return
+        alias_text = str(alias)
+        target_text = str(target)
+        values = node_aliases.setdefault(alias_text, [])
+        if target_text not in values:
+            values.append(target_text)
+
+    def visit_hierarchy(row: Any) -> None:
+        if not isinstance(row, Mapping):
+            return
+        row_id = str(row.get("id") or row.get("link_id") or row.get("node_id") or "")
+        node_id = row.get("node_id")
+        if node_id not in (None, "") and row_id:
+            rpg_links.setdefault(str(node_id), row_id)
+        for code_id in _as_sequence(row.get("mapped_code_node_ids")):
+            add_alias(_graph_node_id({"node_id": code_id}, "code"), row_id)
+            add_alias(code_id, row_id)
+        for code_link in _as_sequence(row.get("mapped_code_link_ids")):
+            add_alias(code_link, row_id)
+        for code_ref in _as_sequence(row.get("mapped_code")):
+            if isinstance(code_ref, Mapping):
+                add_alias(code_ref.get("link_id"), row_id)
+                add_alias(code_ref.get("node_id") or code_ref.get("dep_node_id"), row_id)
+        for child in _as_sequence(row.get("children")):
+            visit_hierarchy(child)
+
+    visit_hierarchy(hierarchy)
 
     for node in semantic_nodes:
-        link_id = _append_graph_node(nodes, seen_nodes, node, "semantic", file_anchors)
+        link_id = str(node.get("link_id") or _graph_node_id(node, "feature"))
         node_id = node.get("node_id")
         if node_id not in (None, ""):
-            rpg_links[str(node_id)] = link_id
+            rpg_links.setdefault(str(node_id), link_id)
     for node in code_nodes:
-        link_id = _append_graph_node(nodes, seen_nodes, node, "code", file_anchors)
+        link_id = str(node.get("link_id") or _graph_node_id(node, "code"))
         node_id = node.get("node_id") or node.get("dep_node_id")
         if node_id not in (None, ""):
             code_links[str(node_id)] = link_id
+            for rpg_link in _as_sequence(node.get("mapped_rpg_link_ids")):
+                add_alias(link_id, rpg_link)
+                add_alias(node_id, rpg_link)
 
-    links: list[dict[str, Any]] = []
     for mapping in mappings:
-        mapping_id = _append_graph_node(nodes, seen_nodes, mapping, "mapping", file_anchors)
-        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
-        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
-        source = mapping.get("source_link_id") or rpg_links.get(str(rpg_id or ""))
-        target = mapping.get("target_link_id") or code_links.get(str(code_id or ""))
-        if source:
-            links.append({"id": f"{mapping_id}-semantic", "source": source, "target": mapping_id, "kind": "mapping", "relation": mapping.get("status") or "mapped"})
-        if target:
-            links.append({"id": f"{mapping_id}-code", "source": mapping_id, "target": target, "kind": "mapping", "relation": mapping.get("source") or "code"})
-
-    for edge in context_edges:
-        source = edge.get("source_link_id")
-        target = edge.get("target_link_id")
-        if not source:
-            source = _append_context_node(nodes, seen_nodes, None, edge.get("source_node_id"))
-        elif str(source) not in seen_nodes:
-            _append_context_node(nodes, seen_nodes, source, edge.get("source_node_id"))
-        if not target:
-            target = _append_context_node(nodes, seen_nodes, None, edge.get("target_node_id"))
-        elif str(target) not in seen_nodes:
-            _append_context_node(nodes, seen_nodes, target, edge.get("target_node_id"))
-        links.append({
-            "id": edge.get("link_id") or f"edge-{len(links) + 1}",
-            "source": str(source),
-            "target": str(target),
-            "kind": "context",
+        source = mapping.get("source_link_id") or rpg_links.get(str(mapping.get("rpg_node_id") or mapping.get("node_id") or ""))
+        target = mapping.get("target_link_id") or code_links.get(str(mapping.get("code_node_id") or mapping.get("dep_node_id") or ""))
+        add_alias(target, source)
+        add_alias(mapping.get("code_node_id") or mapping.get("dep_node_id"), source)
+
+    def edge_kind(edge: Mapping[str, Any]) -> str:
+        source_parts = " ".join(
+            str(edge.get(key) or "")
+            for key in ("source_graph", "edge_source", "relation_source", "source")
+        ).lower()
+        relation = str(edge.get("relation") or "").lower()
+        if "rpg" in source_parts or relation in {"semantic", "depends_on", "related", "relates_to"}:
+            return "semantic"
+        return "dependency"
+
+    def candidates(edge: Mapping[str, Any], side: str) -> list[str]:
+        values: list[Any] = []
+        values.extend(_as_sequence(edge.get(f"{side}_candidates")))
+        values.extend(_as_sequence(edge.get(f"{side}_rpg_link_ids")))
+        values.append(edge.get(f"{side}_link_id"))
+        node_id = edge.get(f"{side}_node_id")
+        values.append(rpg_links.get(str(node_id or "")))
+        values.append(code_links.get(str(node_id or "")))
+        values.append(node_id)
+        expanded: list[str] = []
+        for value in values:
+            if value in (None, ""):
+                continue
+            text = str(value)
+            expanded.append(text)
+            expanded.extend(node_aliases.get(text, []))
+        return _ordered_texts(expanded)
+
+    relation_edges: list[dict[str, Any]] = []
+    for index, edge in enumerate(context_edges, start=1):
+        source_candidates = candidates(edge, "source")
+        target_candidates = candidates(edge, "target")
+        relation_edges.append({
+            "id": str(edge.get("link_id") or f"edge-{index}"),
+            "source": source_candidates[0] if source_candidates else "",
+            "target": target_candidates[0] if target_candidates else "",
+            "source_candidates": source_candidates,
+            "target_candidates": target_candidates,
+            "kind": edge_kind(edge),
             "relation": edge.get("relation") or "dependency",
+            "source_meta": edge.get("source"),
+            "source_graph": edge.get("source_graph"),
+            "edge_source": edge.get("edge_source"),
+            "relation_source": edge.get("relation_source"),
             "direction": edge.get("direction"),
+            "reason": edge.get("reason"),
+            "path": edge.get("path"),
         })
 
-    focused_graph = nodes_view.get("focused_graph") if isinstance(nodes_view.get("focused_graph"), Mapping) else {}
-    hierarchy = nodes_view.get("hierarchy") or focused_graph.get("hierarchy") or {}
-    default_focus = nodes_view.get("default_focus") or focused_graph.get("default_focus") or {}
-    _append_hierarchy_nodes(nodes, links, seen_nodes, hierarchy)
+    links.extend(relation_edges)
     return {
         "schema": "cmind.focused_graph.render.v1",
         "summary": summary,
         "nodes": nodes,
         "links": links,
+        "relation_edges": relation_edges,
         "semantic_nodes": semantic_nodes,
         "code_nodes": code_nodes,
         "mappings": mappings,
@@ -1025,6 +1181,7 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
         "warnings": warnings,
         "hierarchy": hierarchy,
         "default_focus": default_focus,
+        "node_aliases": node_aliases,
     }
 
 
@@ -1040,279 +1197,270 @@ def _focused_graph_runtime() -> str:
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
   const width = Number(svg.getAttribute('width')) || 960;
-  const height = Number(svg.getAttribute('height')) || 480;
+  const height = Number(svg.getAttribute('height')) || 520;
   const defaultFocus = data.default_focus || {};
   const defaultShowEdges = defaultFocus.show_edges !== false;
   const text = value => value === undefined || value === null ? '' : String(value);
   const list = value => Array.isArray(value) ? value : [];
-  let hierarchyDepth = Math.max(0, Number(defaultFocus.hierarchy_depth ?? defaultFocus.edge_depth ?? 1) || 0);
-  const defaultHierarchyDepth = hierarchyDepth;
+  const root = d3.hierarchy(data.hierarchy || {id:'focused-graph-root', name:'Focused graph', children:[]}, d => d.children);
+  const rootHierarchyId = text(root.data.id || 'focused-graph-root');
+  const focusedNodeIds = new Set(list(defaultFocus.focused_tree_node_ids || defaultFocus.focused_node_ids || defaultFocus.node_link_ids).map(text).filter(Boolean));
+  const focusedCodeLinkIds = new Set(list(defaultFocus.focused_code_link_ids).map(text).filter(Boolean));
+  const expandedNodeIds = new Set(list(defaultFocus.default_expanded_node_ids || defaultFocus.expanded_node_ids).map(text).filter(Boolean));
+  const focusedPathNodeIds = new Set(list(defaultFocus.focused_path_node_ids).map(text).filter(Boolean));
+  const defaultExpandedIds = new Set([rootHierarchyId, ...expandedNodeIds]);
   let showEdges = defaultShowEdges;
   let query = '';
   let selectedId = null;
-  let visibleNodeIds = new Set();
-  const collapsedHierarchyIds = new Set();
-  const nodes = list(data.nodes).map((node, index) => ({
-    ...node,
-    id: text(node.id || node.node_id || `node-${index + 1}`),
-    kind: text(node.kind || 'context'),
-    label: text(node.label || node.name || node.node_id || node.id || `node-${index + 1}`),
-  }));
-  const nodeById = new Map(nodes.map(node => [node.id, node]));
-  const links = list(data.links).map((link, index) => {
-    const source = text(link.source && link.source.id ? link.source.id : link.source);
-    const target = text(link.target && link.target.id ? link.target.id : link.target);
-    return {...link, id: text(link.id || `link-${index + 1}`), source, target};
-  }).filter(link => nodeById.has(link.source) && nodeById.has(link.target));
-  const hierarchyNodeById = new Map();
-  const hierarchyParentById = new Map();
-  const hierarchyChildrenById = new Map();
-  const hierarchyDepthById = new Map();
-  const hierarchyAncestorsById = new Map();
-  const rootHierarchyId = text(data.hierarchy && data.hierarchy.id);
-  const adjacency = new Map(nodes.map(node => [node.id, new Set()]));
-  const linksByNode = new Map(nodes.map(node => [node.id, new Set()]));
-
-  function fill(kind) {
-    return kind === 'semantic' ? '#2563eb' : kind === 'code' ? '#16a34a' : kind === 'mapping' ? '#f59e0b' : kind === 'hierarchy' ? '#8b5cf6' : '#64748b';
-  }
-  function linkKey(link) {
-    return text(link.id || `${link.source}-${link.target}`);
-  }
-  function collectHierarchy(row, parentId, depth, ancestors) {
-    if (!row || typeof row !== 'object') return;
-    const id = text(row.id || row.link_id || row.node_id);
-    if (!id) return;
-    const children = list(row.children).map(child => text(child && (child.id || child.link_id || child.node_id))).filter(Boolean);
-    hierarchyNodeById.set(id, row);
-    hierarchyChildrenById.set(id, children);
-    hierarchyDepthById.set(id, depth);
-    hierarchyAncestorsById.set(id, ancestors);
-    if (parentId) hierarchyParentById.set(id, parentId);
-    list(row.children).forEach(child => collectHierarchy(child, id, depth + 1, ancestors.concat(id)));
-  }
-  collectHierarchy(data.hierarchy, '', 0, []);
-  let maxHierarchyDepth = Math.max(1, defaultHierarchyDepth);
-  hierarchyDepthById.forEach(depth => { maxHierarchyDepth = Math.max(maxHierarchyDepth, depth); });
-  const maxDepth = Math.max(maxHierarchyDepth, Math.min(Math.max(nodes.length - 1, 1), 8));
-
-  links.forEach(link => {
-    adjacency.get(link.source)?.add(link.target);
-    adjacency.get(link.target)?.add(link.source);
-    linksByNode.get(link.source)?.add(linkKey(link));
-    linksByNode.get(link.target)?.add(linkKey(link));
+  const allNodeById = {};
+  let nodeById = {};
+  let currentNodes = [];
+  let currentRelationEdges = [];
+
+  root.x0 = height / 2;
+  root.y0 = 0;
+  root.descendants().forEach(d => {
+    d.id = text(d.data.id || d.data.link_id || d.data.node_id || d.data.name);
+    if (!d.id) d.id = `node-${Math.random().toString(36).slice(2)}`;
+    d._allChildren = d.children || null;
+    allNodeById[d.id] = d;
   });
 
-  const defaultFocusIds = new Set(list(defaultFocus.node_link_ids).map(text).filter(id => nodeById.has(id)));
-  const semanticFocusIds = new Set(list(defaultFocus.semantic_node_ids).map(text));
-  const codeFocusIds = new Set(list(defaultFocus.code_node_ids).map(text));
-  const mappingFocusIds = new Set(list(defaultFocus.mapping_link_ids).map(text));
-  nodes.forEach(node => {
-    if (semanticFocusIds.has(text(node.node_id)) || codeFocusIds.has(text(node.node_id)) || mappingFocusIds.has(node.id)) {
-      defaultFocusIds.add(node.id);
-    }
-  });
+  function walkAll(d, visit) {
+    visit(d);
+    list(d._allChildren).forEach(child => walkAll(child, visit));
+  }
 
-  function layout(rows) {
-    const groups = {hierarchy: [], semantic: [], mapping: [], code: [], context: []};
-    rows.forEach(node => (groups[node.kind] || groups.context).push(node));
-    const x = {hierarchy: 90, semantic: 240, mapping: 455, code: 690, context: 850};
-    const marginY = 36;
-    const availableY = Math.max(120, height - marginY * 2);
-    Object.entries(groups).forEach(([kind, groupRows]) => {
-      const gap = groupRows.length > 1 ? Math.min(78, availableY / (groupRows.length - 1)) : 0;
-      const start = height / 2 - ((groupRows.length - 1) * gap) / 2;
-      groupRows.forEach((node, index) => { node.x = x[kind] || width / 2; node.y = start + index * gap; });
+  function initializeDefaultState() {
+    walkAll(root, d => {
+      if (!d._allChildren) return;
+      const keepOpen = d.depth === 0 || defaultExpandedIds.has(d.id) || focusedPathNodeIds.has(d.id);
+      if (keepOpen) {
+        d.children = d._allChildren;
+        d._children = null;
+      } else {
+        d._children = d._allChildren;
+        d.children = null;
+      }
     });
   }
+  initializeDefaultState();
 
-  function expandFromFocus(seedIds, depthLimit) {
-    const visible = new Set([...seedIds].filter(id => nodeById.has(id)));
-    let frontier = new Set(visible);
-    for (let depth = 0; depth < depthLimit && frontier.size; depth += 1) {
-      const next = new Set();
-      frontier.forEach(id => (adjacency.get(id) || new Set()).forEach(neighbor => {
-        if (!visible.has(neighbor)) {
-          visible.add(neighbor);
-          next.add(neighbor);
-        }
-      }));
-      frontier = next;
+  const relationEdges = list(data.relation_edges || data.links).filter(edge => text(edge.relation) !== 'contains');
+  const treemap = d3.tree().nodeSize([28, 250]);
+  const svgSelection = d3.select(svg).attr('viewBox', `0 0 ${width} ${height}`);
+  svgSelection.selectAll('*').remove();
+  const graphLayer = svgSelection.append('g').attr('class', 'focused-graph-layer').attr('transform', 'translate(80,40)');
+  const relationLayer = graphLayer.append('g').attr('class', 'focused-graph-relation-links');
+  const treeLinkLayer = graphLayer.append('g').attr('class', 'focused-graph-tree-links');
+  const nodeLayer = graphLayer.append('g').attr('class', 'focused-graph-nodes');
+  const zoom = d3.zoom().scaleExtent([0.25, 3.5]).on('zoom', event => graphLayer.attr('transform', event.transform));
+  svgSelection.call(zoom).on('dblclick.zoom', null).on('click', event => {
+    if (event.target === svg) {
+      selectedId = null;
+      update(root);
     }
-    return visible;
-  }
+  });
 
-  function nodeMatches(node) {
-    if (!query) return true;
-    return `${node.label} ${node.node_id || ''} ${node.path || ''} ${node.kind || ''}`.toLowerCase().includes(query);
+  function mappedCodeLabel(d) {
+    const path = d.data.mapped_code_path || list(d.data.mapped_code_paths)[0] || '';
+    const symbol = d.data.mapped_code_symbol || list(d.data.mapped_code_symbols)[0] || '';
+    return [path, symbol].filter(Boolean).join(' · ');
   }
 
-  function isCollapsed(nodeId) {
-    return list(hierarchyAncestorsById.get(nodeId)).some(id => collapsedHierarchyIds.has(id));
+  function nodeLabel(d) {
+    const base = text(d.data.label || d.data.feature_name || d.data.name || d.data.node_id || d.id);
+    const mapped = mappedCodeLabel(d);
+    return mapped && !base.includes(mapped) ? `${base} — ${mapped}` : base;
   }
 
-  function nearestHierarchyToggle(nodeId) {
-    return nodeId !== rootHierarchyId && (hierarchyChildrenById.get(nodeId) || []).length ? nodeId : '';
+  function nodeSearchText(d) {
+    return `${nodeLabel(d)} ${d.data.node_id || ''} ${d.data.feature_path || ''} ${d.data.path || ''} ${d.data.mapped_code_path || ''} ${list(d.data.mapped_code_paths).join(' ')} ${d.data.mapped_code_symbol || ''} ${list(d.data.mapped_code_symbols).join(' ')}`.toLowerCase();
   }
 
-  function computeVisibleNodeIds() {
-    const seeds = defaultFocusIds.size ? defaultFocusIds : new Set(nodes.map(node => node.id));
-    const visible = expandFromFocus(seeds, hierarchyDepth);
-    if (hierarchyNodeById.size) {
-      nodes.forEach(node => {
-        const depth = hierarchyDepthById.get(node.id);
-        if (depth !== undefined && depth <= hierarchyDepth) visible.add(node.id);
-      });
-    }
-    if (query) nodes.forEach(node => { if (nodeMatches(node)) visible.add(node.id); });
-    nodes.forEach(node => {
-      if (!nodeMatches(node) || isCollapsed(node.id)) visible.delete(node.id);
-    });
-    if (!visible.size && !query) nodes.forEach(node => { if (!isCollapsed(node.id)) visible.add(node.id); });
-    return visible;
+  function nodeMatches(d) {
+    return query && nodeSearchText(d).includes(query);
   }
 
-  function isLinkVisible(link) {
-    return showEdges && visibleNodeIds.has(link.source) && visibleNodeIds.has(link.target);
+  function diagonal(s, d) {
+    return `M${s.y},${s.x} C${(s.y + d.y) / 2},${s.x} ${(s.y + d.y) / 2},${d.x} ${d.y},${d.x}`;
   }
 
-  layout(nodes);
-  const svgSelection = d3.select(svg).attr('viewBox', `0 0 ${width} ${height}`);
-  svgSelection.selectAll('*').remove();
-  const graphLayer = svgSelection.append('g').attr('class', 'focused-graph-layer');
-  const linkLayer = graphLayer.append('g').attr('class', 'focused-graph-links');
-  const nodeLayer = graphLayer.append('g').attr('class', 'focused-graph-nodes');
-  const zoom = d3.zoom()
-    .scaleExtent([0.35, 3.5])
-    .on('zoom', event => graphLayer.attr('transform', event.transform));
-  svgSelection.call(zoom).on('dblclick.zoom', null).on('click', event => {
-    if (event.target === svg) {
-      selectedId = null;
-      renderVisibility();
+  function openAncestors(d) {
+    let p = d.parent;
+    while (p) {
+      if (p._children) { p.children = p._children; p._children = null; }
+      p = p.parent;
     }
-  });
-
-  const linkSelection = linkLayer.selectAll('line')
-    .data(links, link => linkKey(link))
-    .join('line')
-    .attr('class', 'focused-graph-link')
-    .attr('data-link-id', link => linkKey(link))
-    .attr('stroke', link => link.kind === 'mapping' ? '#f59e0b' : '#94a3b8')
-    .attr('stroke-width', link => link.kind === 'mapping' ? 2 : 1.4)
-    .attr('opacity', .78);
-
-  const drag = d3.drag()
-    .container(() => graphLayer.node())
-    .on('start', function(event) {
-      event.sourceEvent?.stopPropagation();
-      d3.select(this).classed('dragging', true);
-    })
-    .on('drag', function(event, node) {
-      node.x = event.x;
-      node.y = event.y;
-      updatePositions();
-    })
-    .on('end', function() {
-      d3.select(this).classed('dragging', false);
-    });
-
-  const nodeSelection = nodeLayer.selectAll('g')
-    .data(nodes, node => node.id)
-    .join(enter => {
-      const group = enter.append('g')
-        .attr('class', 'focused-graph-node')
-        .attr('data-node-id', node => node.id)
-        .attr('tabindex', 0)
-        .attr('role', 'button');
-      group.append('circle')
-        .attr('r', node => node.kind === 'mapping' ? 6 : 8)
-        .attr('fill', node => fill(node.kind))
-        .attr('stroke', '#fff')
-        .attr('stroke-width', 2);
-      group.append('text')
-        .attr('x', 13)
-        .attr('y', 4)
-        .attr('font-size', 12)
-        .attr('fill', '#1f2937')
-        .text(node => text(node.label || node.id).slice(0, 42));
-      group.append('title').text(node => `${node.kind}: ${node.label || node.id}`);
-      return group;
-    })
-    .call(drag)
-    .on('click', (event, node) => {
-      event.stopPropagation();
-      selectedId = selectedId === node.id ? null : node.id;
-      renderVisibility();
-    })
-    .on('dblclick', (event, node) => {
-      event.stopPropagation();
-      const toggleId = nearestHierarchyToggle(node.id);
-      if (!toggleId) return;
-      if (collapsedHierarchyIds.has(toggleId)) collapsedHierarchyIds.delete(toggleId);
-      else collapsedHierarchyIds.add(toggleId);
-      if (selectedId && isCollapsed(selectedId)) selectedId = null;
-      renderVisibility();
-    });
+  }
 
-  function updatePositions() {
-    linkSelection
-      .attr('x1', link => nodeById.get(link.source)?.x || 0)
-      .attr('y1', link => nodeById.get(link.source)?.y || 0)
-      .attr('x2', link => nodeById.get(link.target)?.x || 0)
-      .attr('y2', link => nodeById.get(link.target)?.y || 0);
-    nodeSelection.attr('transform', node => `translate(${node.x},${node.y})`);
+  function applySearchOpen() {
+    if (!query) return;
+    walkAll(root, d => { if (nodeMatches(d)) openAncestors(d); });
   }
 
-  function renderVisibility() {
-    visibleNodeIds = computeVisibleNodeIds();
-    if (selectedId && !visibleNodeIds.has(selectedId)) selectedId = null;
-    const activeNodes = new Set();
-    const activeLinks = new Set();
-    if (selectedId) {
-      activeNodes.add(selectedId);
-      (adjacency.get(selectedId) || new Set()).forEach(id => activeNodes.add(id));
-      (linksByNode.get(selectedId) || new Set()).forEach(id => activeLinks.add(id));
-    }
-    nodeSelection
-      .classed('hidden', node => !visibleNodeIds.has(node.id))
-      .classed('selected', node => node.id === selectedId)
-      .classed('active', node => Boolean(selectedId && activeNodes.has(node.id)))
-      .classed('dimmed', node => Boolean(selectedId && visibleNodeIds.has(node.id) && !activeNodes.has(node.id)));
-    linkSelection
-      .classed('hidden', link => !isLinkVisible(link))
-      .classed('active', link => Boolean(selectedId && activeLinks.has(linkKey(link))))
-      .classed('dimmed', link => Boolean(selectedId && isLinkVisible(link) && !activeLinks.has(linkKey(link))));
+  function expandAll() {
+    walkAll(root, d => { if (d._children) { d.children = d._children; d._children = null; } });
+    update(root);
   }
 
   function expandDepth() {
-    hierarchyDepth = Math.min(maxDepth, hierarchyDepth + 1);
-    renderVisibility();
+    let minDepth = Infinity;
+    walkAll(root, d => { if (d._children && d.depth < minDepth) minDepth = d.depth; });
+    if (minDepth === Infinity) return;
+    walkAll(root, d => { if (d._children && d.depth === minDepth) { d.children = d._children; d._children = null; } });
+    update(root);
   }
 
   function collapseDepth() {
-    hierarchyDepth = Math.max(0, hierarchyDepth - 1);
-    renderVisibility();
+    let maxDepth = -1;
+    walkAll(root, d => { if (d.children && d.children.length && d.depth > maxDepth) maxDepth = d.depth; });
+    if (maxDepth <= 0) return;
+    walkAll(root, d => { if (d.children && d.children.length && d.depth === maxDepth) { d._children = d.children; d.children = null; } });
+    update(root);
   }
 
-  section.querySelector('[data-action="reset"]')?.addEventListener('click', () => {
-    hierarchyDepth = defaultHierarchyDepth;
-    showEdges = defaultShowEdges;
+  function resetDefault() {
     query = '';
     selectedId = null;
-    collapsedHierarchyIds.clear();
+    showEdges = defaultShowEdges;
+    initializeDefaultState();
     const search = section.querySelector('[data-action="search"]');
     if (search) search.value = '';
     const edges = section.querySelector('[data-action="edges"]');
     if (edges) edges.checked = showEdges;
-    svgSelection.transition().duration(150).call(zoom.transform, d3.zoomIdentity);
-    renderVisibility();
-  });
+    svgSelection.transition().duration(150).call(zoom.transform, d3.zoomIdentity.translate(80, 40));
+    update(root);
+  }
+
+  function cssToken(value) {
+    const token = text(value).toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+    return token || 'unknown';
+  }
+
+  function edgeClass(edge) {
+    const kind = text(edge.kind || edge.source_graph).toLowerCase().includes('rpg') || text(edge.kind).toLowerCase() === 'semantic' ? 'edge-semantic' : 'edge-dependency';
+    const relation = `relation-${cssToken(edge.relation || 'dependency')}`;
+    const source = `source-${cssToken(edge.source_graph || edge.edge_source || edge.source_meta || kind)}`;
+    return `${kind} ${relation} ${source}`;
+  }
+
+  function visibleEndpoint(edge, side) {
+    for (const candidate of list(edge[`${side}_candidates`]).map(text)) {
+      let node = allNodeById[candidate] || nodeById[candidate];
+      while (node) {
+        if (nodeById[node.id]) return nodeById[node.id];
+        node = node.parent;
+      }
+    }
+    let node = allNodeById[text(edge[side])] || nodeById[text(edge[side])];
+    while (node) {
+      if (nodeById[node.id]) return nodeById[node.id];
+      node = node.parent;
+    }
+    return null;
+  }
+
+  function relationPath(source, target) {
+    const sx = source.y + 8, sy = source.x;
+    const dx = target.y - 8, dy = target.x;
+    const midX = Math.max(sx, dx) + 56 + Math.abs(sy - dy) * 0.18;
+    return `M${sx},${sy} Q${midX},${(sy + dy) / 2} ${dx},${dy}`;
+  }
+
+  function drawRelationEdges() {
+    currentRelationEdges = [];
+    if (showEdges) {
+      relationEdges.forEach(edge => {
+        const source = visibleEndpoint(edge, 'source');
+        const target = visibleEndpoint(edge, 'target');
+        if (!source || !target || source === target) return;
+        currentRelationEdges.push({...edge, _source: source, _target: target, _key: `${edge.id || edge.relation}-${source.id}-${target.id}`});
+      });
+    }
+    const rel = relationLayer.selectAll('path.focused-graph-link').data(currentRelationEdges, edge => edge._key);
+    const relEnter = rel.enter().append('path')
+      .attr('class', edge => `focused-graph-link ${edgeClass(edge)}`)
+      .attr('data-link-id', edge => text(edge.id || edge._key))
+      .attr('d', edge => relationPath(edge._source, edge._target));
+    relEnter.append('title');
+    const relUpdate = relEnter.merge(rel)
+      .attr('class', edge => `focused-graph-link ${edgeClass(edge)}${selectedId && (edge._source.id === selectedId || edge._target.id === selectedId) ? ' active' : ''}${selectedId && edge._source.id !== selectedId && edge._target.id !== selectedId ? ' dimmed' : ''}`)
+      .attr('d', edge => relationPath(edge._source, edge._target));
+    relUpdate.select('title').text(edge => `${edge.relation || 'dependency'}\n${edge.source_graph || edge.edge_source || edge.source_meta || edge.kind || ''}\n${edge.path || edge.reason || ''}`);
+    rel.exit().remove();
+  }
+
+  function update(source) {
+    applySearchOpen();
+    const layout = treemap(root);
+    currentNodes = layout.descendants();
+    currentNodes.forEach(d => { d.y = d.depth * 250; });
+    const minX = d3.min(currentNodes, d => d.x) || 0;
+    if (minX < 20) currentNodes.forEach(d => { d.x += 20 - minX; });
+    nodeById = {};
+    currentNodes.forEach(d => { nodeById[d.id] = d; });
+
+    const node = nodeLayer.selectAll('g.focused-graph-node').data(currentNodes, d => d.id);
+    const nodeEnter = node.enter().append('g')
+      .attr('class', 'focused-graph-node')
+      .attr('data-node-id', d => d.id)
+      .attr('tabindex', 0)
+      .attr('role', 'button')
+      .attr('transform', `translate(${source.y0 || 0},${source.x0 || 0})`)
+      .on('click', (event, d) => {
+        event.stopPropagation();
+        selectedId = selectedId === d.id ? null : d.id;
+        update(d);
+      })
+      .on('dblclick', (event, d) => {
+        event.stopPropagation();
+        if (d.children) { d._children = d.children; d.children = null; }
+        else if (d._children) { d.children = d._children; d._children = null; }
+        update(d);
+      });
+    nodeEnter.append('circle').attr('r', d => d._children ? 6 : (d.children ? 5 : 4));
+    nodeEnter.append('text')
+      .attr('dy', 4)
+      .attr('x', d => d.children || d._children ? -10 : 10)
+      .attr('text-anchor', d => d.children || d._children ? 'end' : 'start')
+      .attr('font-size', 12)
+      .attr('fill', '#1f2937')
+      .text(d => nodeLabel(d).length > 46 ? nodeLabel(d).slice(0, 44) + '…' : nodeLabel(d));
+    nodeEnter.append('title').text(d => `${nodeLabel(d)}\n${d.data.feature_path || ''}\n${d.data.mapped_code_path || ''} ${d.data.mapped_code_symbol || ''}`);
+
+    const nodeUpdate = nodeEnter.merge(node);
+    nodeUpdate.transition().duration(250).attr('transform', d => `translate(${d.y},${d.x})`);
+    nodeUpdate
+      .attr('class', d => `focused-graph-node${d.id === selectedId ? ' selected' : ''}${focusedNodeIds.has(d.id) || focusedCodeLinkIds.has(d.id) ? ' focused' : ''}${nodeMatches(d) ? ' search-match' : ''}${selectedId && d.id !== selectedId && !currentRelationEdges.some(edge => edge._source.id === d.id || edge._target.id === d.id) ? ' dimmed' : ''}`);
+    nodeUpdate.select('circle').attr('r', d => d._children ? 6 : (d.children ? 5 : 4));
+    nodeUpdate.select('text')
+      .attr('x', d => d.children || d._children ? -10 : 10)
+      .attr('text-anchor', d => d.children || d._children ? 'end' : 'start');
+    node.exit().transition().duration(180).attr('transform', `translate(${source.y || 0},${source.x || 0})`).remove();
+
+    const treeLinks = layout.links();
+    const link = treeLinkLayer.selectAll('path.focused-graph-tree-link').data(treeLinks, d => d.target.id);
+    link.enter().insert('path', 'g')
+      .attr('class', 'focused-graph-tree-link')
+      .attr('d', () => diagonal({x: source.x0 || 0, y: source.y0 || 0}, {x: source.x0 || 0, y: source.y0 || 0}))
+      .merge(link).transition().duration(250)
+      .attr('d', d => diagonal(d.source, d.target));
+    link.exit().transition().duration(180)
+      .attr('d', () => diagonal({x: source.x || 0, y: source.y || 0}, {x: source.x || 0, y: source.y || 0}))
+      .remove();
+
+    drawRelationEdges();
+    currentNodes.forEach(d => { d.x0 = d.x; d.y0 = d.y; });
+  }
+
+  section.querySelector('[data-action="reset"]')?.addEventListener('click', resetDefault);
+  section.querySelector('[data-action="expand-all"]')?.addEventListener('click', expandAll);
   section.querySelector('[data-action="depth-plus"]')?.addEventListener('click', expandDepth);
   section.querySelector('[data-action="depth-minus"]')?.addEventListener('click', collapseDepth);
-  section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; renderVisibility(); });
-  section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = text(event.target.value).toLowerCase(); renderVisibility(); });
-  updatePositions();
-  renderVisibility();
+  section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; update(root); });
+  section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = text(event.target.value).toLowerCase(); update(root); });
+  update(root);
 })();
 """
 
@@ -1345,30 +1493,30 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     inspector = json.dumps(inspector_payload, indent=2, ensure_ascii=False, default=_json_default)
     controls = (
         '<div class="focused-graph-toolbar">'
-        '<button type="button" data-action="reset">Reset</button>'
-        '<button type="button" data-action="depth-plus" aria-label="Expand hierarchy depth" title="Expand hierarchy depth">+1</button>'
-        '<button type="button" data-action="depth-minus" aria-label="Collapse hierarchy depth" title="Collapse hierarchy depth">-1</button>'
+        '<button type="button" data-action="reset">Reset default</button>'
+        '<button type="button" data-action="expand-all">Expand all</button>'
+        '<button type="button" data-action="depth-plus" title="Expand hierarchy depth">+1</button>'
+        '<button type="button" data-action="depth-minus" title="Collapse hierarchy depth">-1</button>'
         '<label><input type="checkbox" data-action="edges" checked> Edges</label>'
         '<input type="search" data-action="search" placeholder="Search nodes" aria-label="Search focused graph nodes">'
         '</div>'
     )
     legend = (
         '<div class="focused-graph-legend" aria-label="Focused graph legend">'
-        '<span class="legend-item"><span class="legend-swatch legend-semantic"></span>Semantic</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-code"></span>Code</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-mapping"></span>Mapping</span>'
-        '<span class="legend-item"><span class="legend-swatch" style="background:#8b5cf6"></span>Hierarchy</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-context"></span>Context edge</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-node"></span>Feature tree node</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-semantic-edge"></span>RPG semantic edge</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-dependency-edge"></span>dep_graph dependency edge</span>'
         '</div>'
     )
     return (
         '<section class="focused-graph-section" data-focused-graph><h2>Focused graph</h2>'
-        f"{summary_html}{controls}{legend}{warnings_html}{hidden_html}"
+        f"{summary_html}{controls}{legend}"
         f"<script type=\"application/json\" data-focused-graph-json>{graph_json}</script>"
         '<div class="focused-graph-stage">'
-        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="480"></svg>'
+        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="520"></svg>'
         f'<div class="focused-graph-fallback" data-focused-graph-fallback{fallback_hidden}>Static focused graph fallback is available when D3 cannot run.{d3_missing_note}</div>'
         '</div>'
+        f"{warnings_html}{hidden_html}"
         f"<details><summary>Inspector JSON</summary><pre>{_h(inspector)}</pre></details>"
         f"{scripts}"
         '</section>'
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 49c8687..75f80d1 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -501,69 +501,143 @@ def _focused_graph_hierarchy(
         "id": "focused-graph-root",
         "name": "Focused graph",
         "kind": "root",
+        "feature_name": "Focused graph",
+        "feature_path": "Focused graph",
         "meta": {"hidden_counts": hidden_counts, "warnings": len(warnings), "edges": len(edges)},
         "children": [],
     }
-    semantic_root = _hierarchy_child(root, "focused-semantic-root", "Semantic scope", "semantic_group")
-    code_root = _hierarchy_child(root, "focused-code-root", "Code scope", "code_group")
-    mapping_root = _hierarchy_child(root, "focused-mapping-root", "Mappings", "mapping_group")
-    context_root = _hierarchy_child(root, "focused-context-root", "One-hop context", "context_group")
+    code_by_id = {
+        str(node.get("node_id") or node.get("dep_node_id")): node
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+    mapped_ids_by_rpg: Dict[str, List[str]] = {}
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        if rpg_id not in (None, "") and code_id not in (None, ""):
+            mapped_ids_by_rpg.setdefault(str(rpg_id), []).append(str(code_id))
+
+    def code_refs_for(node: Dict[str, Any]) -> List[Dict[str, Any]]:
+        rpg_id = str(node.get("node_id") or "")
+        refs: List[Dict[str, Any]] = []
+        seen: set[str] = set()
+
+        def append_ref(ref: Dict[str, Any]) -> None:
+            key = str(ref.get("node_id") or ref.get("link_id") or ref.get("path") or ref.get("symbol") or "")
+            if not key or key in seen:
+                return
+            seen.add(key)
+            refs.append(ref)
+
+        for item in _listify(node.get("mapped_code")):
+            if not isinstance(item, dict):
+                continue
+            code_id = item.get("node_id") or item.get("dep_node_id")
+            code_id_text = str(code_id or "")
+            code = code_by_id.get(code_id_text, {})
+            path = item.get("path") or code.get("path") or item.get("file") or code.get("file") or code.get("module") or _dep_node_path(code_id_text)
+            symbol = item.get("symbol") or item.get("name") or code.get("symbol") or code.get("name") or _symbol_from_dep(code_id_text, code)
+            row: Dict[str, Any] = {
+                "node_id": code_id_text,
+                "link_id": item.get("link_id") or code.get("link_id") or _node_link_id("code", code_id_text),
+                "path": path,
+                "symbol": symbol,
+            }
+            for key in ("type", "kind", "line_range", "state", "source"):
+                _set_if_present(row, key, item.get(key) or code.get(key))
+            append_ref(row)
+
+        code_ids = _ordered_unique(_listify(node.get("mapped_code_node_ids")) + mapped_ids_by_rpg.get(rpg_id, []))
+        for code_id in code_ids:
+            code = code_by_id.get(code_id, {})
+            path = code.get("path") or code.get("file") or code.get("module") or _dep_node_path(code_id)
+            symbol = code.get("symbol") or code.get("name") or _symbol_from_dep(code_id, code)
+            row = {
+                "node_id": code_id,
+                "link_id": code.get("link_id") or _node_link_id("code", code_id),
+                "path": path,
+                "symbol": symbol,
+            }
+            for key in ("type", "kind", "line_range", "state", "source"):
+                _set_if_present(row, key, code.get(key))
+            append_ref(row)
+        return refs
+
+    def merge_code_metadata(row: Dict[str, Any], refs: List[Dict[str, Any]]) -> None:
+        if not refs:
+            return
+        existing = [item for item in _listify(row.get("mapped_code")) if isinstance(item, dict)]
+        merged: List[Dict[str, Any]] = []
+        seen: set[str] = set()
+        for ref in existing + refs:
+            key = str(ref.get("node_id") or ref.get("link_id") or ref.get("path") or ref.get("symbol") or "")
+            if not key or key in seen:
+                continue
+            seen.add(key)
+            merged.append(ref)
+        row["mapped_code"] = merged
+        row["mapped_code_node_ids"] = _ordered_unique([ref.get("node_id") for ref in merged])
+        row["mapped_code_link_ids"] = _ordered_unique([ref.get("link_id") for ref in merged])
+        row["mapped_code_paths"] = _ordered_unique([ref.get("path") for ref in merged])
+        row["mapped_code_symbols"] = _ordered_unique([ref.get("symbol") for ref in merged])
+        if row["mapped_code_paths"]:
+            row["mapped_code_path"] = row["mapped_code_paths"][0]
+        if row["mapped_code_symbols"]:
+            row["mapped_code_symbol"] = row["mapped_code_symbols"][0]
+        row["mapped_code_count"] = len(merged)
+
+    def feature_path_text(node: Dict[str, Any], group_parts: List[str], feature_name: str) -> str:
+        for key in ("feature_path", "breadcrumb_path", "breadcrumb", "path"):
+            value = node.get(key)
+            parts = _hierarchy_segments(value)
+            if parts:
+                return " / ".join(parts)
+        return " / ".join(group_parts + ([feature_name] if feature_name else []))
 
-    known_link_ids: set[str] = set()
     for node in semantic_nodes:
-        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
-        known_link_ids.add(link_id)
-        leaf = {
+        node_id = str(node.get("node_id") or "")
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node_id))
+        feature_name = str(node.get("name") or node.get("symbol") or node_id or "feature")
+        group_parts = _semantic_hierarchy_parts(node)
+        code_refs = code_refs_for(node)
+        parent = root
+        trail: List[str] = []
+        for part in group_parts:
+            trail.append(part)
+            group = _hierarchy_child(parent, _node_link_id("feature-path", "/".join(trail)), part, "feature_group")
+            group["feature_name"] = part
+            group["feature_path"] = " / ".join(trail)
+            merge_code_metadata(group, code_refs)
+            parent = group
+        leaf: Dict[str, Any] = {
             "id": link_id,
-            "node_id": node.get("node_id"),
-            "name": node.get("name") or node.get("symbol") or node.get("node_id") or "semantic node",
-            "kind": "semantic",
+            "node_id": node_id,
+            "name": feature_name,
+            "feature_name": feature_name,
+            "feature_path": feature_path_text(node, group_parts, feature_name),
+            "kind": "feature",
             "state": node.get("state"),
             "mapping_status": node.get("mapping_status"),
         }
-        _add_hierarchy_path(semantic_root, _semantic_hierarchy_parts(node), leaf, "semantic-path")
-
-    for node in code_nodes:
-        code_id = node.get("node_id") or node.get("dep_node_id")
-        link_id = str(node.get("link_id") or _node_link_id("code", code_id))
-        known_link_ids.add(link_id)
-        leaf = {
-            "id": link_id,
-            "node_id": code_id,
-            "name": node.get("symbol") or node.get("name") or code_id or "code node",
-            "kind": "code",
-            "state": node.get("state"),
-            "path": node.get("path"),
-        }
-        _add_hierarchy_path(code_root, _code_hierarchy_parts(node), leaf, "code-path")
-
-    for mapping in mappings:
-        link_id = str(mapping.get("link_id") or _node_link_id("map", f"{mapping.get('rpg_node_id')}-{mapping.get('code_node_id') or 'missing'}"))
-        known_link_ids.add(link_id)
-        target = mapping.get("code_node_id") or mapping.get("dep_node_id") or "missing mapping"
-        _append_hierarchy_leaf(mapping_root, {
-            "id": link_id,
-            "name": f"{mapping.get('rpg_node_id')} → {target}",
-            "kind": "mapping",
-            "state": mapping.get("state") or mapping.get("status"),
-            "rpg_node_id": mapping.get("rpg_node_id"),
-            "code_node_id": mapping.get("code_node_id") or mapping.get("dep_node_id"),
-        })
-
-    context_link_ids: set[str] = set()
-    for edge in edges:
-        for endpoint_key, link_key in (("source_node_id", "source_link_id"), ("target_node_id", "target_link_id")):
-            link_id = edge.get(link_key)
-            node_id = edge.get(endpoint_key)
-            if link_id in (None, "") or str(link_id) in known_link_ids or str(link_id) in context_link_ids:
-                continue
-            context_link_ids.add(str(link_id))
-            _append_hierarchy_leaf(context_root, {
-                "id": str(link_id),
-                "node_id": node_id,
-                "name": node_id or "context node",
-                "kind": "context",
-            })
+        for key in (
+            "type",
+            "node_type",
+            "path",
+            "breadcrumb",
+            "breadcrumb_path",
+            "locate_status",
+            "score",
+            "reason",
+            "apply_action",
+            "changed_files",
+            "hidden_counts",
+            "warning_types",
+            "source",
+        ):
+            _set_if_present(leaf, key, node.get(key))
+        merge_code_metadata(leaf, code_refs)
+        _append_hierarchy_leaf(parent, leaf)
     return root
 
 
@@ -576,19 +650,93 @@ def _focused_graph_default_focus(
 ) -> Dict[str, Any]:
     semantic_links = [str(node.get("link_id") or _node_link_id("rpg", node.get("node_id"))) for node in semantic_nodes]
     code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
-    changed_code_links = [
-        str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
-        for node in code_nodes
-        if node.get("changed") or node.get("changed_files") or node.get("diff_anchor")
-    ]
+    semantic_link_set = set(semantic_links)
+    code_to_feature_links: Dict[str, List[str]] = {}
+
+    def remember_code_feature(code_link: Any, feature_link: Any) -> None:
+        if code_link in (None, "") or feature_link in (None, ""):
+            return
+        code_text = str(code_link)
+        feature_text = str(feature_link)
+        values = code_to_feature_links.setdefault(code_text, [])
+        if feature_text not in values:
+            values.append(feature_text)
+
+    rpg_link_by_node_id = {
+        str(node.get("node_id")): str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        for node in semantic_nodes
+        if node.get("node_id") not in (None, "")
+    }
+    for mapping in mappings:
+        source = mapping.get("source_link_id") or rpg_link_by_node_id.get(str(mapping.get("rpg_node_id") or mapping.get("node_id") or ""))
+        target = mapping.get("target_link_id") or _node_link_id("code", mapping.get("code_node_id") or mapping.get("dep_node_id"))
+        remember_code_feature(target, source)
+        remember_code_feature(mapping.get("code_node_id") or mapping.get("dep_node_id"), source)
+    for node in code_nodes:
+        code_link = str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        for rpg_link in _listify(node.get("mapped_rpg_link_ids")):
+            remember_code_feature(code_link, rpg_link)
+            remember_code_feature(node.get("node_id") or node.get("dep_node_id"), rpg_link)
+
+    changed_feature_links: List[Any] = []
+    changed_code_links: List[str] = []
+    for node in code_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        if node.get("changed") or node.get("changed_files") or node.get("diff_anchor"):
+            changed_code_links.append(link_id)
+            changed_feature_links.extend(_listify(node.get("mapped_rpg_link_ids")) + code_to_feature_links.get(link_id, []))
     warning_links = []
     for warning in warnings:
         warning_links.extend(_listify(warning.get("node_link_id")) + _listify(warning.get("code_link_id")))
-    node_link_ids = _ordered_unique(semantic_links + changed_code_links + warning_links)
+    node_link_ids = _ordered_unique(semantic_links + changed_feature_links + changed_code_links + warning_links)
     if not node_link_ids:
         node_link_ids = _ordered_unique(semantic_links + code_links)
+
+    expanded_node_ids: List[Any] = ["focused-graph-root"]
+    focused_path_node_ids: List[Any] = []
+    focused_tree_node_ids: List[Any] = []
+    semantic_path_ids_by_link: Dict[str, List[str]] = {}
+    for node in semantic_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        trail: List[str] = []
+        path_ids: List[str] = ["focused-graph-root"]
+        for part in _semantic_hierarchy_parts(node):
+            trail.append(part)
+            path_ids.append(_node_link_id("feature-path", "/".join(trail)))
+        path_ids.append(link_id)
+        semantic_path_ids_by_link[link_id] = path_ids
+
+    def focus_tree_link(link_id: Any) -> None:
+        link_text = str(link_id or "")
+        if not link_text:
+            return
+        feature_links = [link_text] if link_text in semantic_link_set else code_to_feature_links.get(link_text, [])
+        if not feature_links:
+            feature_links = [link_text] if link_text.startswith("feature-path-") or link_text == "focused-graph-root" else []
+        for feature_link in feature_links:
+            path_ids = semantic_path_ids_by_link.get(feature_link, [feature_link])
+            expanded_node_ids.extend(path_ids[:-1])
+            focused_path_node_ids.extend(path_ids)
+            focused_tree_node_ids.append(path_ids[-1])
+
+    for link_id in node_link_ids:
+        focus_tree_link(link_id)
+    if not focused_tree_node_ids:
+        for link_id in semantic_links:
+            focus_tree_link(link_id)
+
+    expanded_node_ids = _ordered_unique(expanded_node_ids)
+    focused_path_node_ids = _ordered_unique(focused_path_node_ids)
+    focused_tree_node_ids = _ordered_unique(focused_tree_node_ids)
+    focused_code_link_ids = _ordered_unique(changed_code_links + [link_id for link_id in node_link_ids if link_id in code_links])
     return {
         "node_link_ids": node_link_ids,
+        "focused_node_ids": node_link_ids,
+        "focused_tree_node_ids": focused_tree_node_ids,
+        "focused_code_link_ids": focused_code_link_ids,
+        "expanded_node_ids": expanded_node_ids,
+        "default_expanded_node_ids": expanded_node_ids,
+        "focused_path_node_ids": focused_path_node_ids,
         "semantic_node_ids": _ordered_unique([node.get("node_id") for node in semantic_nodes]),
         "code_node_ids": _ordered_unique([node.get("node_id") or node.get("dep_node_id") for node in code_nodes]),
         "mapping_link_ids": _ordered_unique([mapping.get("link_id") for mapping in mappings]),
@@ -677,8 +825,30 @@ def _build_nodes_view(
             row["hidden_counts"] = node.get("hidden_counts")
         mapped_code_ids = _ordered_unique(code_ids_by_rpg.get(node_id, []))
         if mapped_code_ids:
+            mapped_code_refs: List[Dict[str, Any]] = []
+            for code_id in mapped_code_ids:
+                code = code_by_id.get(code_id, {})
+                path = code.get("path") or code.get("file") or code.get("module") or _dep_node_path(code_id)
+                symbol = code.get("symbol") or code.get("name") or _symbol_from_dep(code_id, code)
+                ref: Dict[str, Any] = {
+                    "node_id": code_id,
+                    "link_id": _edge_endpoint_link_id(code_id, rpg_by_id, code_by_id),
+                    "path": path,
+                    "symbol": symbol,
+                }
+                for key in ("type", "kind", "line_range", "state", "source"):
+                    _set_if_present(ref, key, code.get(key))
+                mapped_code_refs.append(ref)
+            row["mapped_code"] = mapped_code_refs
             row["mapped_code_node_ids"] = mapped_code_ids
-            row["mapped_code_link_ids"] = [_edge_endpoint_link_id(code_id, rpg_by_id, code_by_id) for code_id in mapped_code_ids]
+            row["mapped_code_link_ids"] = [ref["link_id"] for ref in mapped_code_refs]
+            row["mapped_code_paths"] = _ordered_unique([ref.get("path") for ref in mapped_code_refs])
+            row["mapped_code_symbols"] = _ordered_unique([ref.get("symbol") for ref in mapped_code_refs])
+            if row["mapped_code_paths"]:
+                row["mapped_code_path"] = row["mapped_code_paths"][0]
+            if row["mapped_code_symbols"]:
+                row["mapped_code_symbol"] = row["mapped_code_symbols"][0]
+            row["mapped_code_count"] = len(mapped_code_refs)
         if warnings_by_rpg.get(node_id):
             row["warning_types"] = _ordered_unique([warning.get("type") for warning in warnings_by_rpg[node_id]])
         semantic_nodes.append(row)
@@ -750,7 +920,7 @@ def _build_nodes_view(
             "relation": relation,
             "state": edge.get("status") or "visible",
         }
-        for key in ("direction", "source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
+        for key in ("direction", "source", "source_graph", "edge_source", "relation_source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
             _set_if_present(row, key, edge.get(key))
         edge_rows.append(row)
 
@@ -881,19 +1051,75 @@ def _dep_node_entry(dep_id: str, raw: Dict[str, Any]) -> Dict[str, Any]:
     return row
 
 
+_CONTAINMENT_RELATIONS = {"contains", "CONTAINS", "composes", "COMPOSES"}
+
+
+def _edge_relation(edge: Dict[str, Any], default: str) -> str:
+    attrs = edge.get("attrs") if isinstance(edge.get("attrs"), dict) else {}
+    relation = (
+        edge.get("relation")
+        or edge.get("type")
+        or edge.get("edge_type")
+        or edge.get("kind")
+        or attrs.get("relation")
+        or attrs.get("type")
+        or attrs.get("edge_type")
+        or attrs.get("kind")
+        or default
+    )
+    return str(relation)
+
+
+def _coerce_rpg_edge(edge: Any) -> Optional[Dict[str, Any]]:
+    if isinstance(edge, dict):
+        source = edge.get("source_node_id") or edge.get("source") or edge.get("from") or edge.get("src")
+        target = edge.get("target_node_id") or edge.get("target") or edge.get("to") or edge.get("dst")
+        relation = _edge_relation(edge, "semantic")
+        if relation in _CONTAINMENT_RELATIONS or source in (None, "") or target in (None, ""):
+            return None
+        row = {
+            "source_node_id": str(source),
+            "target_node_id": str(target),
+            "relation": relation,
+            "source": "rpg_semantic",
+            "source_graph": "rpg",
+            "relation_source": "rpg_semantic",
+            "edge_source": "rpg",
+        }
+        for key in ("direction", "name", "path", "reason", "status"):
+            _set_if_present(row, key, edge.get(key))
+        return row
+    if isinstance(edge, (list, tuple)) and len(edge) >= 2:
+        relation = str(edge[2]) if len(edge) >= 3 else "semantic"
+        if relation in _CONTAINMENT_RELATIONS:
+            return None
+        return {"source_node_id": str(edge[0]), "target_node_id": str(edge[1]), "relation": relation, "source": "rpg_semantic", "source_graph": "rpg", "relation_source": "rpg_semantic", "edge_source": "rpg"}
+    return None
+
+
 def _coerce_dep_edge(edge: Any) -> Optional[Dict[str, Any]]:
     if isinstance(edge, dict):
-        source = edge.get("source") or edge.get("from") or edge.get("caller") or edge.get("src")
-        target = edge.get("target") or edge.get("to") or edge.get("callee") or edge.get("dst")
-        relation = edge.get("relation") or edge.get("type") or edge.get("edge_type") or edge.get("kind") or "dep_graph"
-        if source in (None, "") or target in (None, ""):
+        source = edge.get("source_node_id") or edge.get("source") or edge.get("from") or edge.get("caller") or edge.get("src")
+        target = edge.get("target_node_id") or edge.get("target") or edge.get("to") or edge.get("callee") or edge.get("dst")
+        relation = _edge_relation(edge, "dep_graph")
+        if relation in _CONTAINMENT_RELATIONS or source in (None, "") or target in (None, ""):
             return None
-        row = {"source_node_id": str(source), "target_node_id": str(target), "relation": str(relation), "source": "dep_graph"}
+        row = {
+            "source_node_id": str(source),
+            "target_node_id": str(target),
+            "relation": relation,
+            "source": "dep_graph",
+            "source_graph": "dep_graph",
+            "relation_source": "dep_graph",
+            "edge_source": "dep_graph",
+        }
         _set_if_present(row, "reason", edge.get("reason"))
         return row
     if isinstance(edge, (list, tuple)) and len(edge) >= 2:
-        relation = edge[2] if len(edge) >= 3 else "dep_graph"
-        return {"source_node_id": str(edge[0]), "target_node_id": str(edge[1]), "relation": str(relation), "source": "dep_graph"}
+        relation = str(edge[2]) if len(edge) >= 3 else "dep_graph"
+        if relation in _CONTAINMENT_RELATIONS:
+            return None
+        return {"source_node_id": str(edge[0]), "target_node_id": str(edge[1]), "relation": relation, "source": "dep_graph", "source_graph": "dep_graph", "relation_source": "dep_graph", "edge_source": "dep_graph"}
     return None
 
 
@@ -901,13 +1127,14 @@ def _current_rpg_context() -> Tuple[
     Dict[str, Dict[str, Any]],
     Dict[str, Dict[str, Any]],
     List[Dict[str, Any]],
+    List[Dict[str, Any]],
     Dict[str, List[str]],
     Dict[str, List[str]],
     List[Dict[str, Any]],
 ]:
     rpg_data = _load_json_artifact(REPO_RPG_FILE)
     if not isinstance(rpg_data, dict) or rpg_data.get("_error"):
-        return {}, {}, [], {}, {}, [{"type": "stale_graph", "message": f"RPG file not available: {REPO_RPG_FILE}"}]
+        return {}, {}, [], [], {}, {}, [{"type": "stale_graph", "message": f"RPG file not available: {REPO_RPG_FILE}"}]
 
     rpg_nodes: Dict[str, Dict[str, Any]] = {}
 
@@ -994,8 +1221,21 @@ def visit_rpg_node(raw: Any, breadcrumb: List[str]) -> None:
     for dep_id, rpg_ids in list(dep_to_rpg.items()):
         dep_to_rpg[dep_id] = _ordered_unique(rpg_ids)
 
+    def edge_values(value: Any) -> List[Any]:
+        if isinstance(value, dict):
+            return list(value.values())
+        if isinstance(value, (list, tuple, set)):
+            return list(value)
+        return []
+
+    rpg_edges = []
+    for raw_edge in edge_values(rpg_data.get("edges")) + edge_values(rpg_data.get("semantic_edges")) + edge_values(rpg_data.get("feature_edges")):
+        edge = _coerce_rpg_edge(raw_edge)
+        if edge:
+            rpg_edges.append(edge)
+
     dep_edges = []
-    for raw_edge in dep_graph.get("edges") or []:
+    for raw_edge in edge_values(dep_graph.get("edges")) + edge_values(dep_graph.get("syntax_edges")):
         edge = _coerce_dep_edge(raw_edge)
         if edge:
             dep_edges.append(edge)
@@ -1003,7 +1243,7 @@ def visit_rpg_node(raw: Any, breadcrumb: List[str]) -> None:
     warnings: List[Dict[str, Any]] = []
     if not rpg_nodes and not dep_nodes:
         warnings.append({"type": "stale_graph", "message": "Current RPG contains no indexed feature or dependency nodes"})
-    return rpg_nodes, dep_nodes, dep_edges, rpg_to_dep, dep_to_rpg, warnings
+    return rpg_nodes, dep_nodes, rpg_edges, dep_edges, rpg_to_dep, dep_to_rpg, warnings
 
 
 def _feature_evidence_groups(
@@ -1017,7 +1257,7 @@ def _feature_evidence_groups(
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
     apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
     impact_results = _impact_results(artifacts)
-    current_rpg_nodes, current_dep_nodes, current_dep_edges, current_rpg_to_dep, _, graph_warnings = _current_rpg_context()
+    current_rpg_nodes, current_dep_nodes, current_rpg_edges, current_dep_edges, current_rpg_to_dep, _, graph_warnings = _current_rpg_context()
     current_graph_available = bool(current_rpg_nodes or current_dep_nodes)
     locate_ids = {str(row.get("node_id")) for row in locate.get("results") or [] if isinstance(row, dict) and row.get("node_id")}
     applied_by_id = {
@@ -1110,11 +1350,15 @@ def add_edge(edge: Dict[str, Any]) -> None:
         if key in edge_keys:
             return
         edge_keys.add(key)
+        source_graph = edge.get("source_graph") or ("rpg" if source_text_label == "rpg_semantic" else "dep_graph" if source_text_label == "dep_graph" else source_text_label)
         row: Dict[str, Any] = {
             "source_node_id": source_text,
             "target_node_id": target_text,
             "relation": relation_text,
             "source": source_text_label,
+            "source_graph": source_graph,
+            "relation_source": edge.get("relation_source") or source_text_label,
+            "edge_source": edge.get("edge_source") or source_graph,
         }
         for key_name in ("rpg_node_id", "neighbor_node_id", "direction", "name", "path", "reason", "status"):
             _set_if_present(row, key_name, edge.get(key_name))
@@ -1262,6 +1506,11 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         if dep_node.get("path") in changed_files:
             add_code_node(dep_id, source="changed_file", fallback_path=dep_node.get("path"))
 
+    selected_rpg_ids = {row.get("node_id") for row in primary_rpg_nodes_all}
+    for edge in current_rpg_edges:
+        if edge.get("source_node_id") in selected_rpg_ids or edge.get("target_node_id") in selected_rpg_ids:
+            add_edge(edge)
+
     selected_code_ids = set(code_node_by_id)
     for edge in current_dep_edges:
         if edge.get("source_node_id") in selected_code_ids or edge.get("target_node_id") in selected_code_ids:
@@ -1320,6 +1569,7 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         "current_graph_available": current_graph_available,
         "current_rpg_nodes": len(current_rpg_nodes),
         "current_dep_nodes": len(current_dep_nodes),
+        "current_rpg_edges": len(current_rpg_edges),
         "current_dep_edges": len(current_dep_edges),
     }
     nodes_view = _build_nodes_view(

From 1fc9983d0af99d960f0fc04cbb865c172aede149 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 04:13:45 +0000
Subject: [PATCH 37/56] Update rpg_edit command.

---
 CoderMind/templates/commands/rpg_edit.md | 27 ++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/CoderMind/templates/commands/rpg_edit.md b/CoderMind/templates/commands/rpg_edit.md
index 7fbc05b..4aa19e5 100644
--- a/CoderMind/templates/commands/rpg_edit.md
+++ b/CoderMind/templates/commands/rpg_edit.md
@@ -243,7 +243,7 @@ replies above before proceeding. Treat any other free-form reply as
 All work in this step happens on a fresh `rpg-edit/<short-id>` branch
 in the project repo (workspace root), never directly on the user's
 working branch.  The branch is merged back into `<base-branch>` — the
-branch the user was on when the command started — only after Step 5e
+branch the user was on when the command started — only after Step 5d
 tests pass, so a failed run leaves `<base-branch>` clean and the branch
 preserved for inspection.
 
@@ -330,16 +330,20 @@ git add -A && git commit --amend --no-edit
 cmind script smoke_test.py --json
 ```
 
-1. **Impact review** — run targeted tests and verify affected functionality:
+1. **Impact review + final Explain View** — run targeted tests, verify affected functionality, and publish the final `rpg_edit` report:
 
 ```bash
 cmind script rpg_edit/review.py --report-scope final --json
 ```
 
-The outer `rpg_edit` flow owns the sole user-visible final report;
+Use `--report-scope final` exactly once for the outer `rpg_edit` flow.
+It publishes the sole user-visible `CoderMind rpg_edit Explain View`;
 intermediate or nested review runs should use `--report-scope internal`
 or `--no-report` so their artifacts can be linked without publishing a
-second final report.
+second final report. Record `report_path` from stdout for Step 6; if it
+is absent, use `published_to`. If `report_error` is present, keep
+reviewing the JSON result but mention the report generation failure in
+Step 6.
 
 The review script reads the plan and impact JSON from their default
 home-dir locations and automatically:
@@ -348,6 +352,19 @@ home-dir locations and automatically:
 - Runs pytest on matching test files
 - Dispatches a sub-agent to verify affected callers (if impact is large enough)
 
+The final Explain View is the canonical audit surface for `rpg_edit` and
+the reference shape for other CoderMind command reports. When polishing
+reports for other commands, preserve the shared report surfaces from this
+stage — artifact links, summary cards, workflow timeline, verification,
+retrievals, and code/graph deltas — and only replace or extend the
+command-specific evidence sections. For `rpg_edit`, it links the
+`validate`, `locate`, `plan`, `impact`, `code_result`, `apply_result`,
+and `review_result` artifacts (plus any `internal_report_*` artifacts)
+and renders a **Focused graph** from `focused_view` showing selected RPG
+feature groups, mapped dep_graph/code nodes, missing mappings, warnings,
+hidden context, and the default focus. Do NOT create or link a separate
+`focused_graph` artifact — it is now embedded in the final Explain View.
+
 Check the output `type` field:
 
 - `"skipped"`: impact is small, pytest passed or no tests — review not needed
@@ -378,6 +395,7 @@ visible in `git log --graph`.  The user is returned to `<base-branch>`
 - **Success path** (Step 5e completed):
 
   > Merged `rpg-edit/<short-id>` into `<base-branch>` (commit `<merge-SHA>`).
+  > Report: `<report_path_or_published_to>`
   > To revert later:
   > - Code:  `git revert -m 1 <merge-SHA>`
   > - Graphs: `cmind script rpg_edit/apply.py --rollback <timestamp> --json`
@@ -401,6 +419,7 @@ visible in `git log --graph`.  The user is returned to `<base-branch>`
   Report to the user:
 
   > Tests failed.  Branch `rpg-edit/<short-id>` preserved for inspection.
+  > Report: `<report_path_or_published_to>` (if generated)
   > `<base-branch>` is clean.  Choose one of:
   > - Inspect:  `git diff <base-branch> rpg-edit/<short-id>`
   > - Discard code + graphs together:

From 690c12434e2ea0326b7485c46b6e379f23a79202 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 04:21:46 +0000
Subject: [PATCH 38/56] rpg_edit: Extend `_git_delta_files()` at lines 125-142
 to return real

---
 CoderMind/scripts/update_graphs.py      | 510 +++++++++++++++++++++++-
 CoderMind/tests/test_encode_commands.py | 193 ++++++++-
 2 files changed, 673 insertions(+), 30 deletions(-)

diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index 0f48fb2..f2e5a77 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -26,7 +26,7 @@
 import sys
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 SCRIPTS_DIR = Path(__file__).resolve().parent
 if str(SCRIPTS_DIR) not in sys.path:
@@ -34,7 +34,15 @@
 
 from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE, RPG_HTML_FILE, HOOK_CALLS_LOG  # noqa: E402
 from common.rpg_io import atomic_write_rpg, safe_load_rpg  # noqa: E402
-from common.run_events import ArtifactEvent, CommandRun, StepEvent, VerificationEvent  # noqa: E402
+from common.run_events import (  # noqa: E402
+    ArtifactEvent,
+    CodeDeltaEvent,
+    CommandRun,
+    DepGraphDeltaEvent,
+    RPGDeltaEvent,
+    StepEvent,
+    VerificationEvent,
+)
 from common.run_report import write_command_report  # noqa: E402
 
 
@@ -122,12 +130,54 @@ def _format_diff_summary(summary: dict) -> str:
     return ", ".join(parts)
 
 
+def _git_change_type(status: object) -> str:
+    code = str(status or "").upper()
+    if code.startswith("A"):
+        return "added"
+    if code.startswith("D"):
+        return "deleted"
+    if code.startswith("R"):
+        return "renamed"
+    if code.startswith("C"):
+        return "copied"
+    if code.startswith("T"):
+        return "typechanged"
+    if code.startswith("U"):
+        return "unmerged"
+    return "modified" if code.startswith("M") else (code.lower() or "changed")
+
+
+def _git_diff_text(prev_ref: str, workspace_root: str, paths: list[str]) -> str:
+    import subprocess
+
+    if not paths:
+        return ""
+    try:
+        return subprocess.check_output(
+            ["git", "diff", "--relative", f"{prev_ref}..HEAD", "--", *paths],
+            cwd=workspace_root,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return ""
+
+
 def _git_delta_files(prev_ref: str, workspace_root: str) -> list[dict[str, str]]:
     import subprocess
 
     try:
         output = subprocess.check_output(
-            ["git", "diff", "--relative", "--name-status", f"{prev_ref}..HEAD", "--", "."],
+            [
+                "git",
+                "diff",
+                "--relative",
+                "--name-status",
+                "--find-renames",
+                f"{prev_ref}..HEAD",
+                "--",
+                ".",
+            ],
             cwd=workspace_root,
             stderr=subprocess.DEVNULL,
             text=True,
@@ -137,17 +187,367 @@ def _git_delta_files(prev_ref: str, workspace_root: str) -> list[dict[str, str]]
     files: list[dict[str, str]] = []
     for line in output.splitlines():
         parts = line.split("\t")
-        if len(parts) >= 2:
-            files.append({"status": parts[0], "path": parts[-1]})
+        if len(parts) < 2:
+            continue
+        status = parts[0]
+        path = parts[-1]
+        before = parts[1] if status.upper().startswith(("R", "C")) and len(parts) >= 3 else path
+        diff_paths = [before, path] if before != path else [path]
+        row = {
+            "status": status,
+            "change_type": _git_change_type(status),
+            "path": path,
+            "file": path,
+            "diff": _git_diff_text(prev_ref, workspace_root, diff_paths),
+        }
+        if before != path:
+            row["before"] = before
+            row["after"] = path
+        elif row["change_type"] == "added":
+            row["after"] = path
+        elif row["change_type"] == "deleted":
+            row["before"] = path
+        files.append(row)
     return files
 
 
+def _listify(value: Any) -> list[Any]:
+    if value in (None, ""):
+        return []
+    if isinstance(value, dict):
+        return list(value.keys())
+    if isinstance(value, (list, tuple, set)):
+        return list(value)
+    return [value]
+
+
+def _ordered_unique_text(values: list[Any]) -> list[str]:
+    seen: set[str] = set()
+    ordered: list[str] = []
+    for value in values:
+        if value in (None, ""):
+            continue
+        text = str(value)
+        if text in seen:
+            continue
+        seen.add(text)
+        ordered.append(text)
+    return ordered
+
+
+def _code_delta_rows(result: dict) -> list[dict[str, Any]]:
+    rows = result.get("code_deltas") or result.get("git_delta") or []
+    normalized: list[dict[str, Any]] = []
+    for row in _listify(rows):
+        if isinstance(row, dict):
+            path = row.get("file") or row.get("path") or row.get("after") or row.get("before")
+            if path in (None, ""):
+                continue
+            item = dict(row)
+            item["file"] = path
+            item["path"] = path
+            item["change_type"] = item.get("change_type") or _git_change_type(item.get("status"))
+            item.setdefault("diff", "")
+            normalized.append(item)
+        elif row not in (None, ""):
+            normalized.append({"file": str(row), "path": str(row), "change_type": "changed", "diff": ""})
+    return normalized
+
+
+def _diff_files(result: dict) -> list[str]:
+    diff_files = result.get("diff_files")
+    files: list[Any] = []
+    if isinstance(diff_files, dict):
+        for value in diff_files.values():
+            if isinstance(value, dict):
+                files.extend(value.keys())
+            else:
+                files.extend(_listify(value))
+    return _ordered_unique_text(files)
+
+
+def _changed_report_files(result: dict, code_deltas: list[dict[str, Any]]) -> list[str]:
+    files: list[Any] = _diff_files(result)
+    for row in code_deltas:
+        files.append(row.get("file") or row.get("path") or row.get("after") or row.get("before"))
+    return _ordered_unique_text(files)
+
+
+def _load_report_rpg(result: dict) -> dict[str, Any]:
+    rpg_path = result.get("output_path") or result.get("rpg_path")
+    if not rpg_path:
+        return {}
+    try:
+        return safe_load_rpg(Path(str(rpg_path)))
+    except Exception:
+        return {}
+
+
+def _flatten_rpg_tree(root: Any) -> tuple[dict[str, dict[str, Any]], dict[str, str]]:
+    nodes: dict[str, dict[str, Any]] = {}
+    paths: dict[str, str] = {}
+
+    def visit(node: Any, ancestors: list[str]) -> None:
+        if not isinstance(node, dict):
+            return
+        node_id = node.get("id") or node.get("node_id")
+        name = node.get("name") or node_id
+        next_ancestors = ancestors + ([str(name)] if name not in (None, "") else [])
+        if node_id not in (None, ""):
+            node_id_text = str(node_id)
+            nodes[node_id_text] = node
+            paths[node_id_text] = " / ".join(next_ancestors)
+        for child in node.get("children") or []:
+            visit(child, next_ancestors)
+
+    visit(root, [])
+    return nodes, paths
+
+
+def _dep_node_items(dep_nodes: Any) -> list[tuple[str, dict[str, Any]]]:
+    if isinstance(dep_nodes, dict):
+        return [(str(node_id), attrs if isinstance(attrs, dict) else {}) for node_id, attrs in dep_nodes.items()]
+    if isinstance(dep_nodes, list):
+        rows = []
+        for index, attrs in enumerate(dep_nodes):
+            if not isinstance(attrs, dict):
+                continue
+            node_id = attrs.get("id") or attrs.get("node_id") or attrs.get("dep_node_id") or index
+            rows.append((str(node_id), attrs))
+        return rows
+    return []
+
+
+def _dep_node_path(dep_id: str, attrs: dict[str, Any]) -> str:
+    for key in ("path", "file", "module", "code_path"):
+        value = attrs.get(key)
+        if value not in (None, ""):
+            text = str(value)
+            if key == "code_path" and os.path.isabs(text):
+                try:
+                    return os.path.relpath(text, os.getcwd())
+                except ValueError:
+                    return text
+            return text
+    return dep_id.split(":", 1)[0]
+
+
+def _dep_node_matches_file(dep_id: str, attrs: dict[str, Any], file_path: str) -> bool:
+    candidates = {dep_id, dep_id.split(":", 1)[0], _dep_node_path(dep_id, attrs)}
+    for key in ("path", "file", "module", "code_path"):
+        value = attrs.get(key)
+        if value not in (None, ""):
+            candidates.add(str(value))
+    for candidate in candidates:
+        if candidate == file_path or candidate.endswith("/" + file_path):
+            return True
+        if candidate.startswith(file_path + ":"):
+            return True
+    return False
+
+
+def _rpg_node_row(node_id: str, node: dict[str, Any], paths: dict[str, str], changed_files: list[str]) -> dict[str, Any]:
+    meta = node.get("meta") if isinstance(node.get("meta"), dict) else {}
+    return {
+        "node_id": node_id,
+        "name": node.get("name") or node_id,
+        "type": node.get("node_type") or node.get("type") or meta.get("type_name"),
+        "node_type": node.get("node_type") or node.get("type") or meta.get("type_name"),
+        "path": meta.get("path") or node.get("path"),
+        "feature_path": paths.get(node_id, ""),
+        "breadcrumb_path": paths.get(node_id, ""),
+        "change": "semantic",
+        "changed_files": changed_files,
+        "mapping_status": "mapped",
+    }
+
+
+def _dep_node_row(dep_id: str, attrs: dict[str, Any], changed_files: list[str], mapped_rpg_ids: list[str]) -> dict[str, Any]:
+    row: dict[str, Any] = {
+        "node_id": dep_id,
+        "dep_node_id": dep_id,
+        "path": _dep_node_path(dep_id, attrs),
+        "symbol": attrs.get("name") or dep_id.rsplit(":", 1)[-1],
+        "type": attrs.get("type") or attrs.get("kind"),
+        "change": "code",
+        "changed_files": changed_files,
+        "source": "dep_graph",
+    }
+    if attrs.get("signature") not in (None, ""):
+        row["signature"] = attrs.get("signature")
+    start = attrs.get("start_line") or attrs.get("lineno") or attrs.get("line")
+    end = attrs.get("end_line") or start
+    if start not in (None, ""):
+        row["line_range"] = {"start": start, "end": end}
+    if mapped_rpg_ids:
+        row["mapped_rpg_node_ids"] = mapped_rpg_ids
+    return row
+
+
+def _edge_rows(dep_edges: Any, code_ids: set[str]) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    if not isinstance(dep_edges, list):
+        return rows
+    for edge in dep_edges:
+        if not isinstance(edge, dict):
+            continue
+        source = edge.get("src") or edge.get("source") or edge.get("from")
+        target = edge.get("dst") or edge.get("target") or edge.get("to")
+        if source not in code_ids and target not in code_ids:
+            continue
+        attrs = edge.get("attrs") if isinstance(edge.get("attrs"), dict) else {}
+        rows.append({
+            "source_node_id": source,
+            "target_node_id": target,
+            "relation": edge.get("relation") or edge.get("type") or attrs.get("type") or "dependency",
+            "source_graph": "dep_graph",
+            "edge_source": "dep_graph",
+            "reason": "adjacent to changed code",
+        })
+    return rows[:50]
+
+
+def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semantic_total: int) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]]]:
+    changed_files = _changed_report_files(result, code_deltas)
+    rpg_data = _load_report_rpg(result)
+    dep_graph = rpg_data.get("dep_graph") if isinstance(rpg_data.get("dep_graph"), dict) else {}
+    dep_to_rpg = rpg_data.get("_dep_to_rpg_map") if isinstance(rpg_data.get("_dep_to_rpg_map"), dict) else {}
+    rpg_nodes, rpg_paths = _flatten_rpg_tree(rpg_data.get("root"))
+    matched_dep_ids: set[str] = set()
+    code_nodes: list[dict[str, Any]] = []
+    semantic_by_id: dict[str, dict[str, Any]] = {}
+    mappings: list[dict[str, Any]] = []
+    warnings: list[dict[str, Any]] = []
+
+    if semantic_total == 0:
+        warnings.append({
+            "type": "zero_semantic_delta",
+            "message": "RPG semantic delta 为 0",
+            "reason": "diff_summary contains no added, deleted, modified, or renamed semantic files",
+        })
+
+    dep_items = _dep_node_items(dep_graph.get("nodes") if isinstance(dep_graph, dict) else {})
+    for changed_file in changed_files:
+        file_matched = False
+        for dep_id, attrs in dep_items:
+            if not _dep_node_matches_file(dep_id, attrs, changed_file):
+                continue
+            file_matched = True
+            if dep_id in matched_dep_ids:
+                continue
+            mapped_rpg_ids = _ordered_unique_text(_listify(attrs.get("rpg_nodes")) + _listify(dep_to_rpg.get(dep_id)))
+            code_nodes.append(_dep_node_row(dep_id, attrs, [changed_file], mapped_rpg_ids))
+            matched_dep_ids.add(dep_id)
+            for rpg_id in mapped_rpg_ids:
+                node = rpg_nodes.get(rpg_id)
+                if not isinstance(node, dict):
+                    continue
+                semantic_by_id.setdefault(rpg_id, _rpg_node_row(rpg_id, node, rpg_paths, [changed_file]))
+                mappings.append({
+                    "rpg_node_id": rpg_id,
+                    "code_node_id": dep_id,
+                    "dep_node_id": dep_id,
+                    "status": "mapped",
+                    "state": "mapped",
+                    "source": "rpg_json",
+                    "path": _dep_node_path(dep_id, attrs),
+                    "changed_files": [changed_file],
+                })
+        if not file_matched:
+            warnings.append({
+                "type": "unmapped_changed_file",
+                "message": "changed file has no dep_graph node in updated RPG JSON",
+                "path": changed_file,
+            })
+
+    semantic_nodes = list(semantic_by_id.values())
+    dep_edges = _edge_rows(dep_graph.get("edges") if isinstance(dep_graph, dict) else [], matched_dep_ids)
+    unmatched_files = set(changed_files)
+    for node in code_nodes:
+        unmatched_files.difference_update(str(path) for path in _listify(node.get("changed_files")))
+    unmatched_code_deltas = [row for row in code_deltas if (row.get("file") or row.get("path")) in unmatched_files]
+    summary = {
+        "selected_feature_groups": len(semantic_nodes),
+        "primary_rpg_nodes": len(semantic_nodes),
+        "primary_code_nodes": len(code_nodes),
+        "mapped_code_relations": len(mappings),
+        "missing_mappings": len([node for node in code_nodes if not node.get("mapped_rpg_node_ids")]),
+        "edges": len(dep_edges),
+        "warnings": len(warnings),
+        "changed_files": len(changed_files),
+        "semantic_delta": semantic_total,
+    }
+    nodes_view = {
+        "summary": {
+            "semantic_nodes": len(semantic_nodes),
+            "code_nodes": len(code_nodes),
+            "mappings": len(mappings),
+            "edges": len(dep_edges),
+            "warnings": len(warnings),
+            "changed_files": len(changed_files),
+        },
+        "semantic_nodes": semantic_nodes,
+        "code_nodes": code_nodes,
+        "mappings": mappings,
+        "edges": dep_edges,
+        "warnings": warnings,
+        "changed_files": [{"path": file_path} for file_path in changed_files],
+        "hidden_counts": {},
+    }
+    focused_view = {
+        "summary": summary,
+        "nodes_view": nodes_view,
+        "primary_rpg_nodes": semantic_nodes,
+        "primary_code_nodes": code_nodes,
+        "mappings": mappings,
+        "edges": dep_edges,
+        "hidden_counts": {},
+        "warnings": warnings,
+        "changed_files": changed_files,
+        "unmatched_code_deltas": unmatched_code_deltas,
+    }
+    return focused_view, semantic_nodes, code_nodes
+
+
+def _hook_context(result: dict) -> dict[str, Any]:
+    return {
+        "CMIND_HOOK": result.get("CMIND_HOOK", os.environ.get("CMIND_HOOK", "")),
+        "hook_calls_log": result.get("hook_calls_log") or str(HOOK_CALLS_LOG),
+        "update_rpg_log": result.get("update_rpg_log") or str(HOOK_CALLS_LOG.parent / "update_rpg.log"),
+    }
+
+
+def _commit_range(result: dict) -> dict[str, Any]:
+    return {
+        "prev_ref": result.get("prev_ref"),
+        "previous_commit": result.get("previous_commit"),
+        "new_commit": result.get("new_commit"),
+    }
+
+
+def _commit_range_reason(commit_range: dict[str, Any]) -> str:
+    parts = [f"{key}={value}" for key, value in commit_range.items() if value not in (None, "")]
+    return ", ".join(parts) if parts else "not recorded"
+
+
+def _dep_delta_detail(result: dict) -> str:
+    parts = []
+    if result.get("dep_nodes_delta") not in (None, ""):
+        parts.append(f"nodes_delta={result.get('dep_nodes_delta'):+d}" if isinstance(result.get("dep_nodes_delta"), int) else f"nodes_delta={result.get('dep_nodes_delta')}")
+    if result.get("dep_edges_delta") not in (None, ""):
+        parts.append(f"edges_delta={result.get('dep_edges_delta'):+d}" if isinstance(result.get("dep_edges_delta"), int) else f"edges_delta={result.get('dep_edges_delta')}")
+    if result.get("dep_to_rpg_map_size") not in (None, ""):
+        parts.append(f"dep_to_rpg_map_size={result.get('dep_to_rpg_map_size')}")
+    return ", ".join(parts)
+
+
 def _attach_update_report(result: dict) -> dict:
     try:
         semantic_summary = _diff_summary(result)
         semantic_total = sum(semantic_summary.values())
+        code_deltas = _code_delta_rows(result)
         git_delta = result.get("git_delta")
-        git_total = _change_count(git_delta) if git_delta is not None else ""
+        git_total = _change_count(git_delta) if git_delta is not None else _change_count(code_deltas)
         node_count = result.get("node_count", result.get("rpg_nodes", ""))
         rpg_path = result.get("output_path") or result.get("rpg_path")
         dep_summary = ""
@@ -165,13 +565,35 @@ def _attach_update_report(result: dict) -> dict:
                         result.get("dep_edges_delta"),
                     )
                 )
+        semantic_detail = "RPG semantic delta 为 0" if semantic_total == 0 else _format_diff_summary(semantic_summary)
+        dep_detail = _dep_delta_detail(result)
+        focused_view, rpg_delta_rows, dep_delta_rows = _build_update_focus(result, code_deltas, semantic_total)
+        hook_context = _hook_context(result)
+        commit_range = _commit_range(result)
         viz_status = result.get("viz_error") or (
             "ok" if result.get("viz_path") else "not recorded"
         )
-        report_path = write_command_report(CommandRun(
+        status = result.get("status") or ("error" if result.get("error") else result.get("mode"))
+        evidence = dict(result)
+        evidence.update({
+            "code_deltas": code_deltas,
+            "semantic_summary": semantic_summary,
+            "semantic_total": semantic_total,
+            "focused_view_summary": focused_view.get("summary", {}),
+            "commit_range": commit_range,
+            "commit_range_reason": _commit_range_reason(commit_range),
+            "hook_context": hook_context,
+            "artifact_paths": [
+                {"label": "rpg_json", "path": rpg_path},
+                {"label": "rpg_html", "path": result.get("viz_path")},
+                {"label": "hook_calls_log", "path": hook_context["hook_calls_log"]},
+                {"label": "update_rpg_log", "path": hook_context["update_rpg_log"]},
+            ],
+        })
+        report_run = CommandRun(
             command="update_rpg",
             title="CoderMind update_rpg Explain View",
-            status=result.get("status") or ("error" if result.get("error") else result.get("mode")),
+            status=status,
             summary=[
                 {"label": "mode", "value": result.get("mode", "")},
                 {
@@ -179,15 +601,16 @@ def _attach_update_report(result: dict) -> dict:
                     "value": result.get("reason") or result.get("error", ""),
                 },
                 {"label": "git files", "value": git_total},
-                {"label": "semantic files", "value": semantic_total},
+                {"label": "semantic files", "value": semantic_total, "detail": semantic_detail},
                 {
                     "label": "RPG nodes",
                     "value": _format_count_delta(
                         node_count,
                         result.get("nodes_delta"),
                     ),
+                    "detail": f"edges={_format_count_delta(result.get('edge_count'), result.get('edges_delta'))}" if result.get("edge_count") not in (None, "") else "",
                 },
-                {"label": "dep graph", "value": dep_summary},
+                {"label": "dep graph", "value": dep_summary, "detail": dep_detail},
                 {
                     "label": "visualization",
                     "value": result.get("viz_path") or result.get("viz_error", ""),
@@ -205,12 +628,26 @@ def _attach_update_report(result: dict) -> dict:
                 ),
                 StepEvent(
                     name="semantic delta",
-                    status=result.get("mode", ""),
-                    reason=_format_diff_summary(semantic_summary),
+                    status="warning" if semantic_total == 0 else result.get("mode", ""),
+                    reason=semantic_detail,
+                ),
+                StepEvent(
+                    name="commit range",
+                    status=status,
+                    reason=_commit_range_reason(commit_range),
+                ),
+                StepEvent(
+                    name="hook context",
+                    status="recorded",
+                    reason=(
+                        f"CMIND_HOOK={hook_context['CMIND_HOOK'] or 'not set'}, "
+                        f"hook_calls_log={hook_context['hook_calls_log']}, "
+                        f"update_rpg_log={hook_context['update_rpg_log']}"
+                    ),
                 ),
                 StepEvent(
                     name="sync graph",
-                    status=result.get("status") or ("error" if result.get("error") else result.get("mode", "")),
+                    status=status,
                     reason=result.get("reason", ""),
                 ),
                 StepEvent(
@@ -228,13 +665,48 @@ def _attach_update_report(result: dict) -> dict:
             artifacts=[
                 ArtifactEvent(label="rpg_json", path=rpg_path),
                 ArtifactEvent(label="rpg_html", path=result.get("viz_path")),
+                ArtifactEvent(label="hook_calls_log", path=hook_context["hook_calls_log"]),
+                ArtifactEvent(label="update_rpg_log", path=hook_context["update_rpg_log"]),
+            ],
+            rpg_deltas=[
+                RPGDeltaEvent(
+                    node_id=row.get("node_id"),
+                    name=row.get("name"),
+                    type=row.get("node_type") or row.get("type"),
+                    path=row.get("path") or row.get("feature_path"),
+                    change=row.get("change"),
+                )
+                for row in rpg_delta_rows
+            ],
+            dep_graph_deltas=[
+                DepGraphDeltaEvent(
+                    dep_node_id=row.get("dep_node_id") or row.get("node_id"),
+                    path=row.get("path"),
+                    source_feature=", ".join(_ordered_unique_text(_listify(row.get("mapped_rpg_node_ids")))),
+                    change=row.get("change"),
+                )
+                for row in dep_delta_rows
+            ],
+            code_deltas=[
+                CodeDeltaEvent(
+                    file=row.get("file") or row.get("path"),
+                    change_type=row.get("change_type"),
+                    before=row.get("before"),
+                    after=row.get("after"),
+                    diff=row.get("diff"),
+                )
+                for row in code_deltas
             ],
             verification=[
-                VerificationEvent(name="update_rpg", status=result.get("status") or ("error" if result.get("error") else result.get("mode"))),
-                VerificationEvent(name="viz", status=viz_status),
+                VerificationEvent(name="update_rpg", status=status, detail=result.get("reason") or result.get("error")),
+                VerificationEvent(name="viz", status=viz_status, detail=result.get("viz_path") or result.get("viz_error")),
+                VerificationEvent(name="semantic_delta", status="warning" if semantic_total == 0 else "recorded", detail=semantic_detail),
+                VerificationEvent(name="commit_range", status="recorded", detail=_commit_range_reason(commit_range)),
             ],
-            evidence=result,
-        ))
+            evidence=evidence,
+        ).to_dict()
+        report_run["focused_view"] = focused_view
+        report_path = write_command_report(report_run)
         result["report_path"] = str(report_path)
     except Exception as exc:
         result["report_error"] = str(exc)
@@ -687,6 +1159,10 @@ def cmd_update_rpg(
         result["mode"] = "update-rpg"
         result["prev_ref"] = prev_ref
         result["git_delta"] = git_delta
+        result["code_deltas"] = git_delta
+        result["CMIND_HOOK"] = os.environ.get("CMIND_HOOK", "")
+        result["hook_calls_log"] = str(HOOK_CALLS_LOG)
+        result["update_rpg_log"] = str(HOOK_CALLS_LOG.parent / "update_rpg.log")
 
         # Refresh ``rpg.html`` whenever the JSON was actually rewritten.
         # ``run_update_rpg`` returns ``status="success"`` on a normal
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 391cce0..44731be 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -400,48 +400,215 @@ def test_missing_cur_repo_dir(self, tmp_rpg_file):
 def test_attach_update_report_uses_update_rpg_result_fields(tmp_path, monkeypatch):
     import update_graphs
 
+    rpg_path = tmp_path / "rpg.json"
+    rpg_path.write_text(json.dumps({
+        "repo_name": "test_repo",
+        "root": {
+            "id": "root",
+            "name": "test_repo",
+            "node_type": "root",
+            "meta": {"path": "."},
+            "children": [
+                {
+                    "id": "feature_a",
+                    "name": "Refresh graph visualization",
+                    "node_type": "feature",
+                    "meta": {"path": "scripts/a.py:f"},
+                    "children": [],
+                }
+            ],
+        },
+        "_dep_to_rpg_map": {
+            "scripts/a.py": ["feature_a"],
+            "scripts/a.py:f": ["feature_a"],
+        },
+        "dep_graph": {
+            "nodes": {
+                "scripts/a.py": {
+                    "type": "file",
+                    "name": "a.py",
+                    "path": "scripts/a.py",
+                    "rpg_nodes": ["feature_a"],
+                },
+                "scripts/a.py:f": {
+                    "type": "function",
+                    "name": "f",
+                    "path": "scripts/a.py",
+                    "start_line": 10,
+                    "end_line": 12,
+                    "rpg_nodes": ["feature_a"],
+                },
+                "tests/test_a.py": {
+                    "type": "file",
+                    "name": "test_a.py",
+                    "path": "tests/test_a.py",
+                },
+            },
+            "edges": [
+                {
+                    "src": "scripts/a.py:f",
+                    "dst": "tests/test_a.py",
+                    "attrs": {"type": "imports"},
+                }
+            ],
+        },
+    }), encoding="utf-8")
+    viz_path = tmp_path / "rpg.html"
+    viz_path.write_text("<html></html>", encoding="utf-8")
     captured = {}
 
     def fake_write_command_report(run):
-        captured.update(run.to_dict())
+        captured.update(run.to_dict() if hasattr(run, "to_dict") else dict(run))
         return tmp_path / "report.html"
 
+    monkeypatch.setenv("CMIND_HOOK", "PostCommit")
     monkeypatch.setattr(update_graphs, "write_command_report", fake_write_command_report)
 
     result = update_graphs._attach_update_report({
         "mode": "update-rpg",
         "status": "success",
-        "output_path": "/tmp/rpg.json",
+        "output_path": str(rpg_path),
         "node_count": 4504,
+        "edge_count": 15000,
         "nodes_delta": 2,
+        "edges_delta": 7,
         "dep_nodes": 2708,
         "dep_nodes_delta": 46,
         "dep_edges": 5498,
         "dep_edges_delta": 103,
+        "dep_to_rpg_map_size": 2,
         "diff_summary": {
             "added": 0,
             "deleted": 0,
             "modified": 3,
             "renamed": 0,
         },
+        "diff_files": {
+            "added": [],
+            "deleted": [],
+            "modified": ["scripts/a.py", "tests/test_a.py"],
+            "renamed": [],
+        },
         "git_delta": [
-            {"status": "M", "path": "scripts/a.py"},
-            {"status": "M", "path": "tests/test_a.py"},
+            {"status": "M", "change_type": "modified", "path": "scripts/a.py", "diff": "diff --git a/scripts/a.py b/scripts/a.py\n+new"},
+            {"status": "M", "change_type": "modified", "path": "tests/test_a.py", "diff": "diff --git a/tests/test_a.py b/tests/test_a.py\n+test"},
         ],
-        "viz_path": "/tmp/rpg.html",
+        "prev_ref": "prev123",
+        "previous_commit": "old456",
+        "new_commit": "new789",
+        "viz_path": str(viz_path),
     })
 
-    cards = {card["label"]: card["value"] for card in captured["summary"]}
+    cards = {card["label"]: card for card in captured["summary"]}
     artifacts = {artifact["label"]: artifact["path"] for artifact in captured["artifacts"]}
+    steps = {step["name"]: step for step in captured["steps"]}
+    evidence = captured["evidence"]
+    focused = captured["focused_view"]
+    nodes_view = focused["nodes_view"]
+
     assert result["report_path"] == str(tmp_path / "report.html")
-    assert cards["git files"] == 2
-    assert cards["semantic files"] == 3
-    assert cards["RPG nodes"] == "4504 (delta: +2)"
-    assert cards["dep graph"] == "nodes=2708 (delta: +46), edges=5498 (delta: +103)"
-    assert artifacts["rpg_json"] == "/tmp/rpg.json"
+    assert cards["git files"]["value"] == 2
+    assert cards["semantic files"]["value"] == 3
+    assert cards["semantic files"]["detail"] == "3 semantic files, modified=3"
+    assert cards["RPG nodes"]["value"] == "4504 (delta: +2)"
+    assert cards["RPG nodes"]["detail"] == "edges=15000 (delta: +7)"
+    assert cards["dep graph"]["value"] == "nodes=2708 (delta: +46), edges=5498 (delta: +103)"
+    assert "dep_to_rpg_map_size=2" in cards["dep graph"]["detail"]
+    assert artifacts["rpg_json"] == str(rpg_path)
+    assert artifacts["rpg_html"] == str(viz_path)
+    assert artifacts["hook_calls_log"].endswith("hook_calls.jsonl")
+    assert artifacts["update_rpg_log"].endswith("update_rpg.log")
     assert captured["status"] == "success"
-    assert captured["steps"][0]["reason"] == "2 changed files"
-    assert captured["steps"][1]["reason"] == "3 semantic files, modified=3"
+    assert steps["git delta"]["reason"] == "2 changed files"
+    assert steps["semantic delta"]["reason"] == "3 semantic files, modified=3"
+    assert "prev_ref=prev123" in steps["commit range"]["reason"]
+    assert "previous_commit=old456" in steps["commit range"]["reason"]
+    assert "new_commit=new789" in steps["commit range"]["reason"]
+    assert "CMIND_HOOK=PostCommit" in steps["hook context"]["reason"]
+    assert captured["code_deltas"][0]["file"] == "scripts/a.py"
+    assert captured["code_deltas"][0]["change_type"] == "modified"
+    assert "+new" in captured["code_deltas"][0]["diff"]
+    assert captured["rpg_deltas"][0]["node_id"] == "feature_a"
+    assert captured["rpg_deltas"][0]["name"] == "Refresh graph visualization"
+    assert {row["path"] for row in captured["dep_graph_deltas"]} >= {"scripts/a.py", "tests/test_a.py"}
+    assert focused["summary"]["primary_rpg_nodes"] == 1
+    assert focused["summary"]["primary_code_nodes"] == 3
+    assert focused["summary"]["mapped_code_relations"] == 2
+    assert focused["summary"]["missing_mappings"] == 1
+    assert focused["warnings"] == []
+    assert nodes_view["summary"]["semantic_nodes"] == 1
+    assert nodes_view["summary"]["code_nodes"] == 3
+    assert nodes_view["summary"]["mappings"] == 2
+    assert nodes_view["semantic_nodes"][0]["node_id"] == "feature_a"
+    assert nodes_view["code_nodes"][1]["line_range"] == {"start": 10, "end": 12}
+    assert evidence["code_deltas"][1]["file"] == "tests/test_a.py"
+    assert evidence["semantic_summary"] == {"added": 0, "deleted": 0, "modified": 3, "renamed": 0}
+    assert evidence["commit_range"] == {
+        "prev_ref": "prev123",
+        "previous_commit": "old456",
+        "new_commit": "new789",
+    }
+    assert evidence["commit_range_reason"] == "prev_ref=prev123, previous_commit=old456, new_commit=new789"
+    assert evidence["hook_context"]["CMIND_HOOK"] == "PostCommit"
+    assert evidence["hook_context"]["hook_calls_log"].endswith("hook_calls.jsonl")
+    assert evidence["hook_context"]["update_rpg_log"].endswith("update_rpg.log")
+
+
+def test_attach_update_report_warns_on_zero_semantic_delta_without_inventing_nodes(tmp_path, monkeypatch):
+    import update_graphs
+
+    captured = {}
+
+    def fake_write_command_report(run):
+        captured.update(run.to_dict() if hasattr(run, "to_dict") else dict(run))
+        return tmp_path / "zero.html"
+
+    monkeypatch.setattr(update_graphs, "write_command_report", fake_write_command_report)
+
+    result = update_graphs._attach_update_report({
+        "mode": "update-rpg",
+        "status": "success",
+        "output_path": str(tmp_path / "missing-rpg.json"),
+        "node_count": 4504,
+        "nodes_delta": 0,
+        "dep_nodes": 2708,
+        "dep_nodes_delta": 0,
+        "dep_edges": 5498,
+        "dep_edges_delta": 0,
+        "diff_summary": {
+            "added": 0,
+            "deleted": 0,
+            "modified": 0,
+            "renamed": 0,
+        },
+        "git_delta": [
+            {"status": "M", "change_type": "modified", "path": "docs/readme.md", "diff": "+doc"},
+        ],
+        "prev_ref": "prev123",
+        "previous_commit": "old456",
+        "new_commit": "new789",
+    })
+
+    cards = {card["label"]: card for card in captured["summary"]}
+    steps = {step["name"]: step for step in captured["steps"]}
+    focused = captured["focused_view"]
+    nodes_view = focused["nodes_view"]
+    assert result["report_path"] == str(tmp_path / "zero.html")
+    assert cards["semantic files"]["value"] == 0
+    assert cards["semantic files"]["detail"] == "RPG semantic delta 为 0"
+    assert steps["semantic delta"]["status"] == "warning"
+    assert steps["semantic delta"]["reason"] == "RPG semantic delta 为 0"
+    assert captured["verification"][2]["detail"] == "RPG semantic delta 为 0"
+    assert focused["summary"]["primary_rpg_nodes"] == 0
+    assert focused["summary"]["primary_code_nodes"] == 0
+    assert nodes_view["semantic_nodes"] == []
+    assert nodes_view["code_nodes"] == []
+    assert nodes_view["mappings"] == []
+    assert captured.get("rpg_deltas", []) == []
+    assert captured.get("dep_graph_deltas", []) == []
+    assert any(warning["message"] == "RPG semantic delta 为 0" for warning in focused["warnings"])
+    assert any(warning["type"] == "unmapped_changed_file" for warning in focused["warnings"])
+    assert focused["unmatched_code_deltas"][0]["file"] == "docs/readme.md"
 
 
 # ============================================================================

From 657461bd92666b7363321275c5abc4860d4c5dd3 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 05:59:09 +0000
Subject: [PATCH 39/56] rpg_edit: At lines 1519-1567, remove the focused graph
 slicing by _FOC

---
 CoderMind/scripts/common/run_report.py | 172 +++++++++++--
 CoderMind/scripts/rpg_edit/review.py   | 323 +++++++++++++++++++------
 CoderMind/tests/test_run_report.py     | 109 +++++++--
 3 files changed, 487 insertions(+), 117 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 36bc287..18139ac 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -407,10 +407,16 @@ def _render_page(
 .focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed var(--line); border-radius:10px; background:#fff; color:var(--muted); }}
 .focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; }}
 .legend-item {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); font-size:13px; }}
-.legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid var(--line); }}
+.legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid var(--line); flex:0 0 auto; }}
+.legend-line {{ width:28px; height:0; border-radius:0; border:0; border-top:2px solid var(--line); background:transparent; }}
 .legend-node {{ background:#2563eb; }}
-.legend-semantic-edge {{ background:#7c3aed; }}
-.legend-dependency-edge {{ background:#ea580c; }}
+.legend-tree-link {{ border-top-color:#cbd5e1; border-top-width:1.4px; }}
+.legend-semantic-edge {{ border-top-color:#7c3aed; }}
+.legend-dependency-edge, .legend-imports-edge {{ border-top-color:#ea580c; }}
+.legend-invokes-edge, .legend-caller-edge, .legend-callee-edge {{ border-top-color:#16a34a; }}
+.legend-inherits-edge {{ border-top-color:#9333ea; }}
+.legend-references-edge {{ border-top-color:#2563eb; }}
+.legend-dep-graph-edge {{ border-top-style:dashed; }}
 @media (max-width:720px) {{ main {{ padding:22px 12px 36px; }} .focus-map {{ grid-template-columns:1fr; }} table {{ min-width:560px; }} }}
 </style>
 </head>
@@ -679,12 +685,9 @@ def _chain_edge_html(edges: Sequence[Mapping[str, Any]]) -> str:
 
 def _combined_hidden_counts(hidden_counts: Mapping[str, Any]) -> list[tuple[str, int]]:
     relation_keys = {"caller": "callers", "callee": "callees", "import": "imports", "inheritance": "inheritance"}
-    hidden_relations = hidden_counts.get("relations") if isinstance(hidden_counts.get("relations"), Mapping) else {}
     rows: list[tuple[str, int]] = []
     for relation, count_key in relation_keys.items():
         count = hidden_counts.get(count_key) or 0
-        if isinstance(hidden_relations, Mapping):
-            count += hidden_relations.get(relation, 0) or 0
         try:
             count_int = int(count)
         except (TypeError, ValueError):
@@ -698,13 +701,6 @@ def _hidden_context_html(hidden_counts: Mapping[str, Any]) -> str:
     parts = []
     for relation, count in _combined_hidden_counts(hidden_counts):
         parts.append(f"<p class=\"reason\">Hidden {_h(count)} additional {_h(relation)} neighbors.</p>")
-    cap_rows = []
-    for key in ("primary_rpg_nodes", "primary_code_nodes", "edges"):
-        value = hidden_counts.get(key)
-        if value:
-            cap_rows.append(f"<tr><th>{_h(key)}</th><td>{_h(value)}</td></tr>")
-    if cap_rows:
-        parts.append("<table><tbody>" + "".join(cap_rows) + "</tbody></table>")
     return "".join(parts)
 
 
@@ -969,6 +965,8 @@ def _append_hierarchy_nodes(
     links: list[dict[str, Any]],
     seen_nodes: set[str],
     hierarchy: Any,
+    file_anchors: Mapping[str, str],
+    node_metadata_by_id: Mapping[str, Mapping[str, Any]],
 ) -> None:
     if not isinstance(hierarchy, Mapping):
         return
@@ -983,6 +981,7 @@ def visit(row: Any) -> str:
         row_id = node_id(row)
         if row_id and row_id not in seen_nodes:
             seen_nodes.add(row_id)
+            metadata = node_metadata_by_id.get(row_id) or node_metadata_by_id.get(str(row.get("node_id") or "")) or {}
             payload = {
                 "id": row_id,
                 "kind": row.get("kind") or "feature",
@@ -1003,9 +1002,15 @@ def visit(row: Any) -> str:
                 "mapped_code_symbol",
                 "mapped_code_symbols",
                 "mapped_code_count",
+                "changed_files",
+                "diff_anchor",
             ):
-                if row.get(key) not in (None, ""):
-                    payload[key] = row.get(key)
+                value = row.get(key) if row.get(key) not in (None, "") else metadata.get(key)
+                if value not in (None, ""):
+                    payload[key] = value
+            diff_ref = _graph_diff_ref(payload, file_anchors)
+            if diff_ref:
+                payload["diff"] = diff_ref
             nodes.append(payload)
         for child in [child for child in _as_sequence(row.get("children")) if isinstance(child, Mapping)]:
             child_id = visit(child)
@@ -1021,7 +1026,8 @@ def visit(row: Any) -> str:
 
 def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mapping[str, str]) -> dict[str, Any]:
     nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
-    summary = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else focused_view.get("summary", {})
+    summary_source = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else focused_view.get("summary", {})
+    summary = dict(summary_source) if isinstance(summary_source, Mapping) else {}
     semantic_nodes = [node for node in _as_sequence(nodes_view.get("semantic_nodes")) if isinstance(node, Mapping)]
     code_nodes = [node for node in _as_sequence(nodes_view.get("code_nodes")) if isinstance(node, Mapping)]
     mappings = [mapping for mapping in _as_sequence(nodes_view.get("mappings")) if isinstance(mapping, Mapping)]
@@ -1058,10 +1064,95 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
             ],
         }
 
+    semantic_link_by_node = {
+        str(node.get("node_id")): str(node.get("link_id") or _graph_node_id(node, "feature"))
+        for node in semantic_nodes
+        if node.get("node_id") not in (None, "")
+    }
+    code_link_by_node = {
+        str(node.get("node_id") or node.get("dep_node_id")): str(node.get("link_id") or _graph_node_id(node, "code"))
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+    node_metadata_by_id: dict[str, Mapping[str, Any]] = {}
+
+    def remember_node_metadata(alias: Any, row: Mapping[str, Any]) -> None:
+        if alias in (None, ""):
+            return
+        node_metadata_by_id.setdefault(str(alias), row)
+
+    for node in semantic_nodes:
+        node_id = node.get("node_id")
+        remember_node_metadata(node.get("link_id") or _graph_node_id(node, "feature"), node)
+        remember_node_metadata(node_id, node)
+    for node in code_nodes:
+        node_id = node.get("node_id") or node.get("dep_node_id")
+        remember_node_metadata(node.get("link_id") or _graph_node_id(node, "code"), node)
+        remember_node_metadata(node_id, node)
+
+    def endpoint_link_id(edge: Mapping[str, Any], side: str) -> str:
+        node_id = edge.get(f"{side}_node_id")
+        node_text = str(node_id or "")
+        return str(
+            edge.get(f"{side}_link_id")
+            or semantic_link_by_node.get(node_text)
+            or code_link_by_node.get(node_text)
+            or _graph_node_id({"node_id": node_text}, "context")
+        )
+
+    def collect_hierarchy_ids(row: Any, ids: set[str]) -> None:
+        if not isinstance(row, Mapping):
+            return
+        row_id = row.get("id") or row.get("link_id") or row.get("node_id")
+        if row_id not in (None, ""):
+            ids.add(str(row_id))
+        for child in _as_sequence(row.get("children")):
+            collect_hierarchy_ids(child, ids)
+
+    def endpoint_group() -> dict[str, Any]:
+        children = hierarchy.setdefault("children", []) if isinstance(hierarchy, dict) else []
+        group_id = "focused-graph-relation-endpoints"
+        for child in children:
+            if isinstance(child, dict) and child.get("id") == group_id:
+                return child
+        group = {"id": group_id, "name": "Relation endpoints", "kind": "context_group", "children": []}
+        children.append(group)
+        return group
+
+    hierarchy_ids: set[str] = set()
+    collect_hierarchy_ids(hierarchy, hierarchy_ids)
+    for edge in context_edges:
+        for side in ("source", "target"):
+            link_id = endpoint_link_id(edge, side)
+            if not link_id or link_id in hierarchy_ids:
+                continue
+            node_id = edge.get(f"{side}_node_id")
+            node_text = str(node_id or link_id)
+            is_code = node_text in code_link_by_node or link_id in set(code_link_by_node.values())
+            leaf: dict[str, Any] = {
+                "id": link_id,
+                "node_id": node_text,
+                "name": edge.get("name") or edge.get("path") or node_text,
+                "kind": "code" if is_code else "context",
+                "state": "mapped" if is_code else "context",
+                "aliases": _ordered_texts([node_text, link_id]),
+            }
+            if is_code:
+                code = next((row for row in code_nodes if str(row.get("node_id") or row.get("dep_node_id") or "") == node_text), {})
+                for key in ("path", "symbol", "type", "line_range", "source", "changed_files", "diff_anchor"):
+                    if isinstance(code, Mapping) and code.get(key) not in (None, ""):
+                        leaf[key] = code.get(key)
+            else:
+                for key in ("relation", "direction", "path", "reason", "source", "source_graph", "edge_source", "relation_source"):
+                    if edge.get(key) not in (None, ""):
+                        leaf[key] = edge.get(key)
+            endpoint_group().setdefault("children", []).append(leaf)
+            hierarchy_ids.add(link_id)
+
     nodes: list[dict[str, Any]] = []
     links: list[dict[str, Any]] = []
     seen_nodes: set[str] = set()
-    _append_hierarchy_nodes(nodes, links, seen_nodes, hierarchy)
+    _append_hierarchy_nodes(nodes, links, seen_nodes, hierarchy, file_anchors, node_metadata_by_id)
 
     rpg_links: dict[str, str] = {}
     code_links: dict[str, str] = {}
@@ -1081,8 +1172,15 @@ def visit_hierarchy(row: Any) -> None:
             return
         row_id = str(row.get("id") or row.get("link_id") or row.get("node_id") or "")
         node_id = row.get("node_id")
+        kind = str(row.get("kind") or "")
         if node_id not in (None, "") and row_id:
-            rpg_links.setdefault(str(node_id), row_id)
+            if kind in {"code", "context"}:
+                add_alias(node_id, row_id)
+                add_alias(row_id, row_id)
+            else:
+                rpg_links.setdefault(str(node_id), row_id)
+        for alias in _as_sequence(row.get("aliases")):
+            add_alias(alias, row_id)
         for code_id in _as_sequence(row.get("mapped_code_node_ids")):
             add_alias(_graph_node_id({"node_id": code_id}, "code"), row_id)
             add_alias(code_id, row_id)
@@ -1166,6 +1264,14 @@ def candidates(edge: Mapping[str, Any], side: str) -> list[str]:
             "path": edge.get("path"),
         })
 
+    summary.update({
+        "semantic_nodes": len(semantic_nodes),
+        "code_nodes": len(code_nodes),
+        "mappings": len(mappings),
+        "edges": len(context_edges),
+        "relation_edges": len(relation_edges),
+        "context_edges": len(context_edges),
+    })
     links.extend(relation_edges)
     return {
         "schema": "cmind.focused_graph.render.v1",
@@ -1193,6 +1299,7 @@ def _focused_graph_runtime() -> str:
   const dataEl = section.querySelector('[data-focused-graph-json]');
   const svg = section.querySelector('[data-focused-graph-svg]');
   const fallback = section.querySelector('[data-focused-graph-fallback]');
+  const statusEl = section.querySelector('[data-focused-graph-status]');
   if (!window.d3 || !dataEl || !svg) return;
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
@@ -1368,6 +1475,13 @@ def _focused_graph_runtime() -> str:
     return `M${sx},${sy} Q${midX},${(sy + dy) / 2} ${dx},${dy}`;
   }
 
+  function updateStatus() {
+    if (!statusEl) return;
+    const visible = showEdges ? currentRelationEdges.length : 0;
+    const total = relationEdges.length;
+    statusEl.textContent = `Visible relation edges: ${visible}/${total}`;
+  }
+
   function drawRelationEdges() {
     currentRelationEdges = [];
     if (showEdges) {
@@ -1389,13 +1503,16 @@ def _focused_graph_runtime() -> str:
       .attr('d', edge => relationPath(edge._source, edge._target));
     relUpdate.select('title').text(edge => `${edge.relation || 'dependency'}\n${edge.source_graph || edge.edge_source || edge.source_meta || edge.kind || ''}\n${edge.path || edge.reason || ''}`);
     rel.exit().remove();
+    updateStatus();
   }
 
   function update(source) {
     applySearchOpen();
     const layout = treemap(root);
     currentNodes = layout.descendants();
-    currentNodes.forEach(d => { d.y = d.depth * 250; });
+    const maxDepth = d3.max(currentNodes, d => d.depth) || 1;
+    const depthGap = Math.max(140, Math.min(250, (width - 260) / maxDepth));
+    currentNodes.forEach(d => { d.y = d.depth * depthGap; });
     const minX = d3.min(currentNodes, d => d.x) || 0;
     if (minX < 20) currentNodes.forEach(d => { d.x += 20 - minX; });
     nodeById = {};
@@ -1469,7 +1586,8 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     nodes_view = focused_view.get("nodes_view") if isinstance(focused_view.get("nodes_view"), Mapping) else {}
     if not focused_view and not nodes_view:
         return ""
-    summary = nodes_view.get("summary") if isinstance(nodes_view.get("summary"), Mapping) else focused_view.get("summary", {})
+    graph_payload = _focused_graph_payload(focused_view, file_anchors)
+    summary = graph_payload.get("summary") if isinstance(graph_payload.get("summary"), Mapping) else {}
     summary_html = _summary_badges(summary, [
         ("Semantic nodes", "semantic_nodes", len(_as_sequence(nodes_view.get("semantic_nodes")))),
         ("Code nodes", "code_nodes", len(_as_sequence(nodes_view.get("code_nodes")))),
@@ -1481,7 +1599,7 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     hidden_html = _hidden_context_html(hidden_counts if isinstance(hidden_counts, Mapping) else {})
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings") or focused_view.get("warnings")) if isinstance(warning, Mapping)]
     warnings_html = f"<h3>Warnings</h3>{_chain_warning_html(warnings)}" if warnings else ""
-    graph_payload = _focused_graph_payload(focused_view, file_anchors)
+    relation_edge_total = len(_as_sequence(graph_payload.get("relation_edges") or graph_payload.get("edges") or graph_payload.get("links")))
     graph_json = _json_for_script(graph_payload)
     d3_js = _inline_d3()
     fallback_hidden = " hidden" if d3_js else ""
@@ -1499,13 +1617,21 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         '<button type="button" data-action="depth-minus" title="Collapse hierarchy depth">-1</button>'
         '<label><input type="checkbox" data-action="edges" checked> Edges</label>'
         '<input type="search" data-action="search" placeholder="Search nodes" aria-label="Search focused graph nodes">'
+        f'<span class="badge" data-focused-graph-status>Visible relation edges: 0/{relation_edge_total}</span>'
         '</div>'
     )
     legend = (
         '<div class="focused-graph-legend" aria-label="Focused graph legend">'
         '<span class="legend-item"><span class="legend-swatch legend-node"></span>Feature tree node</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-semantic-edge"></span>RPG semantic edge</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-dependency-edge"></span>dep_graph dependency edge</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-tree-link"></span>Tree link</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-semantic-edge"></span>RPG semantic edge</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-dependency-edge legend-dep-graph-edge"></span>dep_graph dependency edge</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-invokes-edge"></span>invokes</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-imports-edge legend-dep-graph-edge"></span>imports</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-inherits-edge"></span>inherits</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-references-edge"></span>references</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-caller-edge"></span>caller</span>'
+        '<span class="legend-item"><span class="legend-swatch legend-line legend-callee-edge"></span>callee</span>'
         '</div>'
     )
     return (
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 75f80d1..5160a33 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -511,6 +511,15 @@ def _focused_graph_hierarchy(
         for node in code_nodes
         if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
     }
+    semantic_link_by_id = {
+        str(node.get("node_id")): str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        for node in semantic_nodes
+        if node.get("node_id") not in (None, "")
+    }
+    code_link_by_id = {
+        code_id: str(node.get("link_id") or _node_link_id("code", code_id))
+        for code_id, node in code_by_id.items()
+    }
     mapped_ids_by_rpg: Dict[str, List[str]] = {}
     for mapping in mappings:
         rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
@@ -595,6 +604,91 @@ def feature_path_text(node: Dict[str, Any], group_parts: List[str], feature_name
                 return " / ".join(parts)
         return " / ".join(group_parts + ([feature_name] if feature_name else []))
 
+    attached_endpoint_ids: set[str] = set()
+
+    def make_code_leaf(ref: Dict[str, Any]) -> Dict[str, Any]:
+        code_id = str(ref.get("node_id") or ref.get("dep_node_id") or "")
+        code = code_by_id.get(code_id, {})
+        path = ref.get("path") or code.get("path") or code.get("file") or code.get("module") or _dep_node_path(code_id)
+        symbol = ref.get("symbol") or ref.get("name") or code.get("symbol") or code.get("name") or _symbol_from_dep(code_id, code)
+        leaf: Dict[str, Any] = {
+            "id": str(ref.get("link_id") or code.get("link_id") or _node_link_id("code", code_id)),
+            "node_id": code_id,
+            "dep_node_id": code_id,
+            "name": symbol or path or code_id,
+            "symbol": symbol,
+            "path": path,
+            "kind": "code",
+            "state": ref.get("state") or code.get("state") or _node_state(code, "mapped"),
+            "aliases": _ordered_unique([code_id, ref.get("link_id"), code.get("link_id")]),
+        }
+        for key in ("type", "line_range", "source", "changed", "changed_files", "diff_anchor"):
+            _set_if_present(leaf, key, ref.get(key) or code.get(key))
+        return leaf
+
+    def endpoint_leaf(edge: Dict[str, Any], side: str) -> Optional[Dict[str, Any]]:
+        node_id = edge.get(f"{side}_node_id")
+        node_text = str(node_id or "")
+        link_id = edge.get(f"{side}_link_id") or semantic_link_by_id.get(node_text) or code_link_by_id.get(node_text)
+        if link_id in (None, "") and node_text:
+            link_id = _node_link_id("context", node_text)
+        link_text = str(link_id or "")
+        if not link_text or link_text in set(semantic_link_by_id.values()):
+            return None
+        if node_text in code_by_id:
+            return make_code_leaf({"node_id": node_text, "link_id": link_text})
+        leaf: Dict[str, Any] = {
+            "id": link_text,
+            "node_id": node_text or link_text,
+            "name": edge.get("name") or edge.get("path") or node_text or "context",
+            "kind": "context",
+            "state": edge.get("state") or "context",
+            "relation": edge.get("relation"),
+            "direction": edge.get("direction"),
+            "source": edge.get("source") or edge.get("source_graph") or edge.get("edge_source"),
+            "aliases": _ordered_unique([node_text, link_text]),
+        }
+        for key in ("path", "reason", "source_graph", "edge_source", "relation_source"):
+            _set_if_present(leaf, key, edge.get(key))
+        return leaf
+
+    def append_endpoint(parent: Dict[str, Any], leaf: Dict[str, Any]) -> None:
+        leaf_id = str(leaf.get("id") or "")
+        if not leaf_id or leaf_id in attached_endpoint_ids:
+            return
+        attached_endpoint_ids.add(leaf_id)
+        _append_hierarchy_leaf(parent, leaf)
+
+    def relation_endpoint_refs(node_id: str, link_id: str, code_refs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        feature_tokens = set(_ordered_unique([node_id, link_id]))
+        for ref in code_refs:
+            feature_tokens.update(_ordered_unique([ref.get("node_id"), ref.get("link_id")]))
+        refs: List[Dict[str, Any]] = []
+        seen: set[str] = set()
+        for edge in edges:
+            edge_tokens = _ordered_unique([
+                edge.get("rpg_node_id"),
+                edge.get("source_node_id"),
+                edge.get("target_node_id"),
+                edge.get("source_link_id"),
+                edge.get("target_link_id"),
+            ])
+            if not feature_tokens.intersection(edge_tokens):
+                continue
+            for side in ("source", "target"):
+                leaf = endpoint_leaf(edge, side)
+                if not leaf:
+                    continue
+                leaf_id = str(leaf.get("id") or "")
+                if not leaf_id or leaf_id in feature_tokens or leaf_id in seen:
+                    continue
+                seen.add(leaf_id)
+                refs.append(leaf)
+        return refs
+
+    def endpoint_group(parent: Dict[str, Any], owner_id: str, name: str, kind: str) -> Dict[str, Any]:
+        return _hierarchy_child(parent, _node_link_id(kind, owner_id), name, kind)
+
     for node in semantic_nodes:
         node_id = str(node.get("node_id") or "")
         link_id = str(node.get("link_id") or _node_link_id("rpg", node_id))
@@ -637,7 +731,46 @@ def feature_path_text(node: Dict[str, Any], group_parts: List[str], feature_name
         ):
             _set_if_present(leaf, key, node.get(key))
         merge_code_metadata(leaf, code_refs)
+        code_group: Optional[Dict[str, Any]] = None
+        for ref in code_refs:
+            if code_group is None:
+                code_group = endpoint_group(leaf, link_id, "Mapped code", "code_group")
+            append_endpoint(code_group, make_code_leaf(ref))
+        context_group: Optional[Dict[str, Any]] = None
+        for ref in relation_endpoint_refs(node_id, link_id, code_refs):
+            group_kind = "code_group" if ref.get("kind") == "code" else "context_group"
+            group_name = "Mapped code" if group_kind == "code_group" else "Relation endpoints"
+            if group_kind == "code_group":
+                if code_group is None:
+                    code_group = endpoint_group(leaf, link_id, group_name, group_kind)
+                append_endpoint(code_group, ref)
+            else:
+                if context_group is None:
+                    context_group = endpoint_group(leaf, link_id, group_name, group_kind)
+                append_endpoint(context_group, ref)
         _append_hierarchy_leaf(parent, leaf)
+
+    root_code_group: Optional[Dict[str, Any]] = None
+    for code in code_nodes:
+        code_id = str(code.get("node_id") or code.get("dep_node_id") or "")
+        if not code_id:
+            continue
+        leaf = make_code_leaf({"node_id": code_id, "link_id": code.get("link_id")})
+        if str(leaf.get("id") or "") in attached_endpoint_ids:
+            continue
+        if root_code_group is None:
+            root_code_group = endpoint_group(root, "unassigned", "Additional code context", "code_group")
+        append_endpoint(root_code_group, leaf)
+
+    root_context_group: Optional[Dict[str, Any]] = None
+    for edge in edges:
+        for side in ("source", "target"):
+            leaf = endpoint_leaf(edge, side)
+            if not leaf or str(leaf.get("id") or "") in attached_endpoint_ids:
+                continue
+            if root_context_group is None:
+                root_context_group = endpoint_group(root, "unassigned", "Additional relation endpoints", "context_group")
+            append_endpoint(root_context_group, leaf)
     return root
 
 
@@ -652,6 +785,7 @@ def _focused_graph_default_focus(
     code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
     semantic_link_set = set(semantic_links)
     code_to_feature_links: Dict[str, List[str]] = {}
+    hierarchy_paths_by_link: Dict[str, List[str]] = {}
 
     def remember_code_feature(code_link: Any, feature_link: Any) -> None:
         if code_link in (None, "") or feature_link in (None, ""):
@@ -662,21 +796,113 @@ def remember_code_feature(code_link: Any, feature_link: Any) -> None:
         if feature_text not in values:
             values.append(feature_text)
 
+    def remember_path(alias: Any, path_ids: List[str]) -> None:
+        if alias in (None, "") or not path_ids:
+            return
+        alias_text = str(alias)
+        if alias_text not in hierarchy_paths_by_link:
+            hierarchy_paths_by_link[alias_text] = path_ids
+
     rpg_link_by_node_id = {
         str(node.get("node_id")): str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
         for node in semantic_nodes
         if node.get("node_id") not in (None, "")
     }
+    semantic_path_ids_by_link: Dict[str, List[str]] = {}
+    for node in semantic_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        trail: List[str] = []
+        path_ids: List[str] = ["focused-graph-root"]
+        for part in _semantic_hierarchy_parts(node):
+            trail.append(part)
+            path_ids.append(_node_link_id("feature-path", "/".join(trail)))
+        path_ids.append(link_id)
+        semantic_path_ids_by_link[link_id] = path_ids
+        remember_path(link_id, path_ids)
+        remember_path(node.get("node_id"), path_ids)
+
+    code_link_by_node_id = {
+        str(node.get("node_id") or node.get("dep_node_id")): str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+
     for mapping in mappings:
         source = mapping.get("source_link_id") or rpg_link_by_node_id.get(str(mapping.get("rpg_node_id") or mapping.get("node_id") or ""))
-        target = mapping.get("target_link_id") or _node_link_id("code", mapping.get("code_node_id") or mapping.get("dep_node_id"))
+        target_node_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        target = mapping.get("target_link_id") or code_link_by_node_id.get(str(target_node_id or "")) or _node_link_id("code", target_node_id)
         remember_code_feature(target, source)
-        remember_code_feature(mapping.get("code_node_id") or mapping.get("dep_node_id"), source)
+        remember_code_feature(target_node_id, source)
     for node in code_nodes:
-        code_link = str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        node_id = node.get("node_id") or node.get("dep_node_id")
+        code_link = str(node.get("link_id") or _node_link_id("code", node_id))
         for rpg_link in _listify(node.get("mapped_rpg_link_ids")):
             remember_code_feature(code_link, rpg_link)
-            remember_code_feature(node.get("node_id") or node.get("dep_node_id"), rpg_link)
+            remember_code_feature(node_id, rpg_link)
+
+    for code_id, code_link in code_link_by_node_id.items():
+        feature_links = code_to_feature_links.get(code_link) or code_to_feature_links.get(code_id) or []
+        if feature_links:
+            for feature_link in feature_links:
+                base_path = semantic_path_ids_by_link.get(str(feature_link))
+                if not base_path:
+                    continue
+                code_path = base_path + [_node_link_id("code_group", feature_link), code_link]
+                remember_path(code_link, code_path)
+                remember_path(code_id, code_path)
+        else:
+            code_path = ["focused-graph-root", _node_link_id("code_group", "unassigned"), code_link]
+            remember_path(code_link, code_path)
+            remember_path(code_id, code_path)
+
+    endpoint_link_ids: List[Any] = []
+    context_link_ids: List[Any] = []
+
+    def endpoint_link(edge: Dict[str, Any], side: str) -> str:
+        node_id = edge.get(f"{side}_node_id")
+        node_text = str(node_id or "")
+        return str(
+            edge.get(f"{side}_link_id")
+            or rpg_link_by_node_id.get(node_text)
+            or code_link_by_node_id.get(node_text)
+            or _node_link_id("context", node_text)
+        )
+
+    def owner_feature_links(edge: Dict[str, Any]) -> List[str]:
+        owners: List[Any] = []
+        owners.append(rpg_link_by_node_id.get(str(edge.get("rpg_node_id") or "")))
+        for side in ("source", "target"):
+            node_id = edge.get(f"{side}_node_id")
+            link_id = endpoint_link(edge, side)
+            if str(node_id or "") in rpg_link_by_node_id:
+                owners.append(rpg_link_by_node_id[str(node_id)])
+            owners.extend(code_to_feature_links.get(str(node_id or ""), []))
+            owners.extend(code_to_feature_links.get(link_id, []))
+        return _ordered_unique(owners)
+
+    for edge in edges:
+        owners = owner_feature_links(edge)
+        for side in ("source", "target"):
+            link_id = endpoint_link(edge, side)
+            node_id = edge.get(f"{side}_node_id")
+            endpoint_link_ids.append(link_id)
+            endpoint_link_ids.append(node_id)
+            if link_id in semantic_link_set:
+                continue
+            if link_id in code_links or str(node_id or "") in code_link_by_node_id:
+                continue
+            context_link_ids.append(link_id)
+            context_path_base = None
+            for feature_link in owners:
+                base_path = semantic_path_ids_by_link.get(str(feature_link))
+                if base_path:
+                    context_path_base = base_path + [_node_link_id("context_group", feature_link)]
+                    break
+            if context_path_base is None:
+                context_path_base = ["focused-graph-root", _node_link_id("context_group", "unassigned")]
+            context_path = context_path_base + [link_id]
+            remember_path(link_id, context_path)
+            remember_path(node_id, context_path)
 
     changed_feature_links: List[Any] = []
     changed_code_links: List[str] = []
@@ -695,29 +921,25 @@ def remember_code_feature(code_link: Any, feature_link: Any) -> None:
     expanded_node_ids: List[Any] = ["focused-graph-root"]
     focused_path_node_ids: List[Any] = []
     focused_tree_node_ids: List[Any] = []
-    semantic_path_ids_by_link: Dict[str, List[str]] = {}
-    for node in semantic_nodes:
-        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
-        trail: List[str] = []
-        path_ids: List[str] = ["focused-graph-root"]
-        for part in _semantic_hierarchy_parts(node):
-            trail.append(part)
-            path_ids.append(_node_link_id("feature-path", "/".join(trail)))
-        path_ids.append(link_id)
-        semantic_path_ids_by_link[link_id] = path_ids
 
     def focus_tree_link(link_id: Any) -> None:
         link_text = str(link_id or "")
         if not link_text:
             return
+        path_ids = hierarchy_paths_by_link.get(link_text)
+        if path_ids:
+            expanded_node_ids.extend(path_ids[:-1])
+            focused_path_node_ids.extend(path_ids)
+            focused_tree_node_ids.append(path_ids[-1])
+            return
         feature_links = [link_text] if link_text in semantic_link_set else code_to_feature_links.get(link_text, [])
         if not feature_links:
             feature_links = [link_text] if link_text.startswith("feature-path-") or link_text == "focused-graph-root" else []
         for feature_link in feature_links:
-            path_ids = semantic_path_ids_by_link.get(feature_link, [feature_link])
-            expanded_node_ids.extend(path_ids[:-1])
-            focused_path_node_ids.extend(path_ids)
-            focused_tree_node_ids.append(path_ids[-1])
+            feature_path = semantic_path_ids_by_link.get(feature_link, [feature_link])
+            expanded_node_ids.extend(feature_path[:-1])
+            focused_path_node_ids.extend(feature_path)
+            focused_tree_node_ids.append(feature_path[-1])
 
     for link_id in node_link_ids:
         focus_tree_link(link_id)
@@ -741,6 +963,8 @@ def focus_tree_link(link_id: Any) -> None:
         "code_node_ids": _ordered_unique([node.get("node_id") or node.get("dep_node_id") for node in code_nodes]),
         "mapping_link_ids": _ordered_unique([mapping.get("link_id") for mapping in mappings]),
         "edge_link_ids": _ordered_unique([edge.get("link_id") for edge in edges]),
+        "relation_endpoint_link_ids": _ordered_unique(endpoint_link_ids),
+        "context_node_ids": _ordered_unique(context_link_ids),
         "edge_depth": 1,
         "show_edges": True,
     }
@@ -753,7 +977,6 @@ def _focused_graph_metadata(
     edges: List[Dict[str, Any]],
     hidden_counts: Dict[str, Any],
     warnings: List[Dict[str, Any]],
-    caps: Optional[Dict[str, Any]],
     graph_context: Optional[Dict[str, Any]],
 ) -> Dict[str, Any]:
     hierarchy = _focused_graph_hierarchy(semantic_nodes, code_nodes, mappings, edges, hidden_counts, warnings)
@@ -763,8 +986,6 @@ def _focused_graph_metadata(
         "hierarchy": hierarchy,
         "default_focus": default_focus,
     }
-    if caps:
-        focused_graph["caps"] = caps
     if graph_context:
         focused_graph["graph_context"] = graph_context
     if hidden_counts:
@@ -784,7 +1005,6 @@ def _build_nodes_view(
     changed_files: List[str],
     diff_anchors: Dict[str, str],
     *,
-    caps: Optional[Dict[str, Any]] = None,
     graph_context: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     rpg_by_id = {str(row.get("node_id")): row for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
@@ -932,7 +1152,6 @@ def _build_nodes_view(
         edge_rows,
         hidden_counts,
         warning_rows,
-        caps or {},
         graph_context or {},
     )
     return {
@@ -954,15 +1173,13 @@ def _build_nodes_view(
         "hierarchy": focused_graph["hierarchy"],
         "default_focus": focused_graph["default_focus"],
         "focused_graph": focused_graph,
-        "caps": caps or {},
+        "caps": dict(_LEGACY_FOCUSED_VIEW_CAPS),
         "graph_context": graph_context or {},
     }
 
 
-_FOCUSED_RPG_NODE_CAP = 20
-_FOCUSED_CODE_NODE_CAP = 50
-_FOCUSED_EDGE_CAP = 80
-_FOCUSED_WARNING_TYPES = {"missing_mapping", "missing_reason", "too_many_neighbors", "stale_graph"}
+_LEGACY_FOCUSED_VIEW_CAPS = {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
+_FOCUSED_WARNING_TYPES = {"missing_mapping", "missing_reason", "stale_graph"}
 
 
 def _set_if_present(row: Dict[str, Any], key: str, value: Any) -> None:
@@ -1516,55 +1733,21 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         if edge.get("source_node_id") in selected_code_ids or edge.get("target_node_id") in selected_code_ids:
             add_edge(edge)
 
-    primary_rpg_nodes = primary_rpg_nodes_all[:_FOCUSED_RPG_NODE_CAP]
+    primary_rpg_nodes = primary_rpg_nodes_all
     primary_code_nodes_all = list(code_node_by_id.values())
-    primary_code_nodes = primary_code_nodes_all[:_FOCUSED_CODE_NODE_CAP]
-    visible_rpg_ids = {row.get("node_id") for row in primary_rpg_nodes}
-    visible_code_ids = {row.get("node_id") for row in primary_code_nodes}
-    mappings = [
-        row for row in mapping_rows_all
-        if row.get("rpg_node_id") in visible_rpg_ids and (not row.get("code_node_id") or row.get("code_node_id") in visible_code_ids)
-    ]
-    edges = all_edges[:_FOCUSED_EDGE_CAP]
-    hidden_counts: Dict[str, Any] = {
-        "primary_rpg_nodes": max(0, len(primary_rpg_nodes_all) - len(primary_rpg_nodes)),
-        "primary_code_nodes": max(0, len(primary_code_nodes_all) - len(primary_code_nodes)),
-        "edges": max(0, len(all_edges) - len(edges)),
-    }
+    primary_code_nodes = primary_code_nodes_all
+    mappings = mapping_rows_all
+    edges = all_edges
+    hidden_counts: Dict[str, Any] = {}
     for key, count in impact_hidden_counts.items():
-        hidden_counts[key] = hidden_counts.get(key, 0) + count
-    relation_totals: Dict[str, int] = {}
-    relation_visible: Dict[str, int] = {}
-    for edge in all_edges:
-        relation = str(edge.get("relation") or "dependency")
-        relation_totals[relation] = relation_totals.get(relation, 0) + 1
-    for edge in edges:
-        relation = str(edge.get("relation") or "dependency")
-        relation_visible[relation] = relation_visible.get(relation, 0) + 1
-    hidden_relations = {
-        relation: total - relation_visible.get(relation, 0)
-        for relation, total in relation_totals.items()
-        if total > relation_visible.get(relation, 0)
-    }
-    if hidden_relations:
-        hidden_counts["relations"] = hidden_relations
-    capped_hidden = {
-        key: value for key, value in hidden_counts.items()
-        if key in {"primary_rpg_nodes", "primary_code_nodes", "edges"} and value
-    }
-    if capped_hidden:
-        add_warning("too_many_neighbors", "Focused view omitted rows because caps were reached", hidden_counts=capped_hidden)
+        if count:
+            hidden_counts[key] = hidden_counts.get(key, 0) + count
 
     matched_files = {file_path for node in primary_rpg_nodes_all for file_path in node.get("changed_files") or []}
     unmatched_code_deltas = [delta for delta in code_deltas if _code_delta_file(delta) not in matched_files]
     mapped_code_relations = sum(1 for row in mapping_rows_all if row.get("code_node_id"))
     missing_mappings = sum(1 for row in mapping_rows_all if row.get("status") == "missing")
     diff_anchors = _diff_anchor_map(code_deltas)
-    focused_caps = {
-        "primary_rpg_nodes": _FOCUSED_RPG_NODE_CAP,
-        "primary_code_nodes": _FOCUSED_CODE_NODE_CAP,
-        "edges": _FOCUSED_EDGE_CAP,
-    }
     graph_context = {
         "current_graph_available": current_graph_available,
         "current_rpg_nodes": len(current_rpg_nodes),
@@ -1581,7 +1764,6 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         warnings,
         changed_files,
         diff_anchors,
-        caps=focused_caps,
         graph_context=graph_context,
     )
     summary = {
@@ -1612,7 +1794,6 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         "warnings": warnings,
         "changed_files": changed_files,
         "unmatched_code_deltas": unmatched_code_deltas,
-        "caps": focused_caps,
         "apply": {
             "status": _apply_status(apply_result),
             "dep_graph_refreshed": apply_result.get("dep_graph_refreshed"),
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 2f12d8e..741422a 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import html as html_lib
+import json
 import sys
 from pathlib import Path
 
@@ -139,8 +141,8 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
                         "semantic_nodes": 2,
                         "code_nodes": 1,
                         "mappings": 2,
-                        "edges": 2,
-                        "warnings": 4,
+                        "edges": 3,
+                        "warnings": 3,
                     },
                     "semantic_nodes": [
                         {
@@ -221,12 +223,23 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
                             "source": "impact",
                             "reason": "reaches <reason>",
                         },
+                        {
+                            "source_node_id": "a.py:f<script>",
+                            "target_node_id": "imported<script>",
+                            "source_link_id": "code-a.py-f-script",
+                            "target_link_id": "context-imported-script",
+                            "relation": "imports",
+                            "direction": "downstream",
+                            "path": "imported.py<script>",
+                            "source": "dep_graph",
+                            "source_graph": "dep_graph",
+                            "reason": "imports <reason>",
+                        },
                     ],
-                    "hidden_counts": {"callers": 3, "edges": 1, "relations": {"caller": 1}},
+                    "hidden_counts": {"callers": 3},
                     "warnings": [
                         {"type": "missing_mapping", "message": "Missing <mapping>", "node_id": "n2", "node_link_id": "rpg-n2"},
                         {"type": "missing_reason", "message": "Missing <reason>", "node_id": "n3"},
-                        {"type": "too_many_neighbors", "message": "Too many <neighbors>", "hidden_counts": {"edges": 1}},
                         {"type": "stale_graph", "message": "Stale <graph>", "dep_node_id": "old.py:f"},
                     ],
                     "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
@@ -241,13 +254,33 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
                     },
                     "default_focus": {
                         "node_link_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                        "focused_node_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                        "focused_tree_node_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                        "focused_code_link_ids": ["code-a.py-f-script"],
+                        "expanded_node_ids": ["focused-graph-root"],
+                        "default_expanded_node_ids": ["focused-graph-root"],
+                        "focused_path_node_ids": ["focused-graph-root", "rpg-n1-script", "code-a.py-f-script"],
+                        "relation_endpoint_link_ids": ["context-caller-script", "code-a.py-f-script", "context-callee-script", "context-imported-script"],
+                        "context_node_ids": ["context-caller-script", "context-callee-script", "context-imported-script"],
                         "edge_depth": 1,
                         "show_edges": True,
                     },
                     "focused_graph": {
                         "schema": "cmind.focused_graph.v1",
                         "hierarchy": {"id": "focused-graph-root"},
-                        "default_focus": {"node_link_ids": ["rpg-n1-script"]},
+                        "default_focus": {
+                            "node_link_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                            "focused_node_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                            "focused_tree_node_ids": ["rpg-n1-script", "code-a.py-f-script"],
+                            "focused_code_link_ids": ["code-a.py-f-script"],
+                            "expanded_node_ids": ["focused-graph-root"],
+                            "default_expanded_node_ids": ["focused-graph-root"],
+                            "focused_path_node_ids": ["focused-graph-root", "rpg-n1-script", "code-a.py-f-script"],
+                            "relation_endpoint_link_ids": ["context-caller-script", "code-a.py-f-script", "context-callee-script", "context-imported-script"],
+                            "context_node_ids": ["context-caller-script", "context-callee-script", "context-imported-script"],
+                            "edge_depth": 1,
+                            "show_edges": True,
+                        },
                     },
                 },
                 "primary_rpg_nodes": [
@@ -303,12 +336,21 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
                         "source": "impact",
                         "reason": "reaches <reason>",
                     },
+                    {
+                        "source_node_id": "n1<script>",
+                        "target_node_id": "imported<script>",
+                        "relation": "imports",
+                        "direction": "downstream",
+                        "path": "imported.py<script>",
+                        "source": "dep_graph",
+                        "source_graph": "dep_graph",
+                        "reason": "imports <reason>",
+                    },
                 ],
-                "hidden_counts": {"callers": 3, "edges": 1, "relations": {"caller": 1}},
+                "hidden_counts": {"callers": 3},
                 "warnings": [
                     {"type": "missing_mapping", "message": "Missing <mapping>", "node_id": "n2"},
                     {"type": "missing_reason", "message": "Missing <reason>", "node_id": "n3"},
-                    {"type": "too_many_neighbors", "message": "Too many <neighbors>", "hidden_counts": {"edges": 1}},
                     {"type": "stale_graph", "message": "Stale <graph>", "dep_node_id": "old.py:f"},
                 ],
             },
@@ -337,37 +379,37 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "data-action=\"depth-minus\"" in html
     assert "data-action=\"edges\"" in html
     assert "data-action=\"search\"" in html
+    assert "data-focused-graph-status" in html
+    assert "Visible relation edges: 0/3" in html
     assert "Reset" in html
     assert "+1" in html
     assert "-1" in html
     assert "Edges" in html
     assert "Search nodes" in html
     assert "d3.zoom()" in html
-    assert "d3.drag()" in html
-    assert ".on('start', function(event) {" in html
-    assert "selectedId = node.id;\n      d3.select(this).classed('dragging', true)" not in html
     assert "dblclick" in html
     assert "focused-graph-layer" in html
     assert "focused-graph-node.selected" in html
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
-    assert "Hierarchy" in html
-    assert '"kind": "hierarchy"' in html
-    assert "const groups = {hierarchy: [], semantic: [], mapping: [], code: [], context: []};" in html
-    assert "const availableY = Math.max(120, height - marginY * 2);" in html
-    assert "collapsedHierarchyIds" in html
-    assert "return list(hierarchyAncestorsById.get(nodeId)).some(id => collapsedHierarchyIds.has(id));" in html
-    assert "if (collapsedHierarchyIds.has(nodeId)) return true;" not in html
-    assert "return nodeId !== rootHierarchyId && (hierarchyChildrenById.get(nodeId) || []).length ? nodeId : '';" in html
-    assert "return hierarchyNodeById.has(nodeId) ? nodeId : '';" not in html
-    assert "visibleNodeIds" in html
+    assert "rootHierarchyId" in html
+    assert "defaultExpandedIds" in html
+    assert "visibleEndpoint" in html
+    assert "updateStatus" in html
+    assert "const visible = showEdges ? currentRelationEdges.length : 0;" in html
+    assert "const total = relationEdges.length;" in html
+    assert "statusEl.textContent = `Visible relation edges: ${visible}/${total}`;" in html
     assert "expandDepth" in html
     assert "collapseDepth" in html
     assert "Expand hierarchy depth" in html
     assert "Collapse hierarchy depth" in html
     assert "d3.zoomIdentity" in html
     assert "Static focused graph fallback is available when D3 cannot run." in html
+    for label in ("Tree link", "RPG semantic edge", "dep_graph dependency edge", "invokes", "imports", "inherits", "references", "caller", "callee"):
+        assert label in html
+    for klass in ("legend-tree-link", "legend-invokes-edge", "legend-imports-edge", "legend-inherits-edge", "legend-references-edge", "legend-caller-edge", "legend-callee-edge"):
+        assert klass in html
     assert "semantic_nodes" in html
     assert "code_nodes" in html
     assert "mappings" in html
@@ -395,10 +437,10 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "Missing &lt;mapping&gt;" in html
     assert "missing_mapping" in html
     assert "missing_reason" in html
-    assert "too_many_neighbors" in html
+    assert "too_many_neighbors" not in html
     assert "stale_graph" in html
-    assert "Hidden 4 additional caller neighbors." in html
-    assert '"caller": 1' in html
+    assert "Hidden 3 additional caller neighbors." in html
+    assert '"edges": 1' not in html
     assert html.count("+line 0 &lt;script&gt;alert(0)&lt;/script&gt;") == 1
     assert "+line 0 <script>alert(0)</script>" not in html
     assert "Node <unsafe>" not in html
@@ -406,6 +448,26 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "maps because <reason>" not in html
     assert "<details><summary>View diff</summary>" in html
     assert "<details open" not in html
+    graph_json = html.split("data-focused-graph-json>", 1)[1].split("</script>", 1)[0]
+    graph_payload = json.loads(html_lib.unescape(graph_json))
+    assert len(graph_payload["edges"]) == 3
+    assert len(graph_payload["relation_edges"]) == 3
+    assert graph_payload["summary"]["edges"] == 3
+    assert graph_payload["summary"]["relation_edges"] == 3
+    assert graph_payload["summary"]["context_edges"] == 3
+    relation_links = [link for link in graph_payload["links"] if link.get("relation") != "contains"]
+    assert len(relation_links) == 3
+    assert any(node["id"] == "context-callee-script" for node in graph_payload["nodes"])
+    assert any(node["id"] == "context-imported-script" for node in graph_payload["nodes"])
+    assert any("context-callee-script" in edge["target_candidates"] for edge in graph_payload["relation_edges"])
+    assert any(edge["relation"] == "imports" and "context-imported-script" in edge["target_candidates"] for edge in graph_payload["relation_edges"])
+    assert any("rpg-n1-script" in edge["source_candidates"] for edge in graph_payload["relation_edges"])
+    assert any("code-a.py-f-script" in edge["source_candidates"] for edge in graph_payload["relation_edges"])
+    default_focus = graph_payload["default_focus"]
+    assert "focused-graph-root" in default_focus["default_expanded_node_ids"]
+    assert "rpg-n1-script" in default_focus["focused_path_node_ids"]
+    assert "context-callee-script" not in default_focus["default_expanded_node_ids"]
+    assert graph_payload["hidden_counts"] == {"callers": 3}
     inspector_json = html.split("<summary>Inspector JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
     assert "focused_graph" in inspector_json
     assert "nodes_view" in inspector_json
@@ -414,6 +476,7 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "default_focus" in inspector_json
     assert "primary_rpg_nodes" not in inspector_json
     assert "primary_code_nodes" not in inspector_json
+    assert "caps" not in inspector_json
     assert long_diff not in inspector_json
     evidence_json = html.split("<summary>Evidence JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
     assert "code_deltas" not in evidence_json

From e49ed9cf417eeb646bdc29f25b5a003c1e91ee7b Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 09:53:21 +0000
Subject: [PATCH 40/56] rpg_edit: In _append_hierarchy_nodes() at lines
 963-1024, preserve add

---
 CoderMind/scripts/common/run_report.py | 257 ++++++++++++++++++++++---
 CoderMind/tests/test_run_report.py     |  53 ++++-
 2 files changed, 272 insertions(+), 38 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 18139ac..29b496c 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -380,34 +380,48 @@ def _render_page(
 .focus-links {{ display:flex; flex-wrap:wrap; gap:6px; }}
 .focus-link {{ border:1px solid var(--line); border-radius:999px; padding:2px 8px; background:#fff; font-size:12px; }}
 .focused-graph-section {{ overflow-x:hidden; }}
-.focused-graph-toolbar {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; }}
-.focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid var(--line); border-radius:8px; background:#fff; color:var(--text); padding:6px 10px; font:inherit; }}
-.focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); }}
-.focused-graph-stage {{ border:1px solid var(--line); border-radius:12px; background:#fbfdff; min-height:520px; position:relative; overflow:hidden; }}
+.focused-graph-toolbar {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a; color:#e5e7eb; }}
+.focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb; padding:6px 10px; font:inherit; }}
+.focused-graph-toolbar input::placeholder {{ color:#94a3b8; }}
+.focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:#cbd5e1; }}
+.focused-graph-stage {{ border:1px solid #334155; border-radius:12px; background:#0f172a; min-height:520px; position:relative; overflow:hidden; }}
 .focused-graph-svg {{ display:block; width:100%; height:520px; cursor:grab; touch-action:none; }}
 .focused-graph-svg:active {{ cursor:grabbing; }}
-.focused-graph-tree-link {{ fill:none; stroke:#cbd5e1; stroke-width:1.4; }}
-.focused-graph-link {{ fill:none; opacity:.78; transition:opacity .15s ease, stroke-width .15s ease; }}
+.focused-graph-detail {{ position:absolute; top:14px; right:14px; z-index:2; width:min(320px,calc(100% - 28px)); max-height:calc(100% - 28px); overflow:auto; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.94); color:#e5e7eb; padding:12px; box-shadow:0 18px 40px rgba(2,6,23,.35); }}
+.focused-graph-detail h3 {{ margin:0 0 8px; font-size:15px; color:#f8fafc; overflow-wrap:anywhere; }}
+.focused-graph-detail dl {{ margin:0; display:grid; gap:8px; }}
+.focused-graph-detail-row {{ display:grid; gap:3px; }}
+.focused-graph-detail dt {{ color:#94a3b8; font-size:11px; text-transform:uppercase; letter-spacing:.04em; }}
+.focused-graph-detail dd {{ margin:0; font-size:13px; overflow-wrap:anywhere; }}
+.focused-graph-detail a {{ color:#93c5fd; }}
+.focused-graph-detail code {{ color:#bfdbfe; }}
+.focused-graph-detail .empty {{ color:#94a3b8; }}
+.focused-graph-detail-badges {{ display:flex; flex-wrap:wrap; gap:6px; margin-bottom:10px; }}
+.focused-graph-detail-badges .badge {{ background:#1e293b; color:#cbd5e1; }}
+.focused-graph-detail-list {{ margin:0; padding-left:18px; }}
+.focused-graph-detail-list span {{ display:block; color:#94a3b8; font-size:12px; }}
+.focused-graph-tree-link {{ fill:none; stroke:#64748b; stroke-width:1.4; }}
+.focused-graph-link {{ fill:none; opacity:.86; transition:opacity .15s ease, stroke-width .15s ease; }}
 .focused-graph-link.active {{ opacity:1; stroke-width:2.8; }}
 .focused-graph-link.dimmed {{ opacity:.14; }}
 .focused-graph-link.hidden {{ display:none; }}
-.focused-graph-link.edge-semantic {{ stroke:#7c3aed; }}
-.focused-graph-link.edge-dependency {{ stroke:#ea580c; }}
-.focused-graph-link.relation-invokes, .focused-graph-link.relation-caller, .focused-graph-link.relation-callee {{ stroke:#16a34a; }}
-.focused-graph-link.relation-imports, .focused-graph-link.relation-import {{ stroke:#ea580c; }}
-.focused-graph-link.relation-inherits, .focused-graph-link.relation-inheritance {{ stroke:#9333ea; }}
-.focused-graph-link.relation-references, .focused-graph-link.relation-reference {{ stroke:#2563eb; }}
+.focused-graph-link.edge-semantic {{ stroke:#a78bfa; }}
+.focused-graph-link.edge-dependency {{ stroke:#fb923c; }}
+.focused-graph-link.relation-invokes, .focused-graph-link.relation-caller, .focused-graph-link.relation-callee {{ stroke:#4ade80; }}
+.focused-graph-link.relation-imports, .focused-graph-link.relation-import {{ stroke:#fb923c; }}
+.focused-graph-link.relation-inherits, .focused-graph-link.relation-inheritance {{ stroke:#c084fc; }}
+.focused-graph-link.relation-references, .focused-graph-link.relation-reference {{ stroke:#60a5fa; }}
 .focused-graph-link.source-dep-graph {{ stroke-dasharray:5 3; }}
 .focused-graph-node {{ cursor:pointer; transition:opacity .15s ease; }}
-.focused-graph-node circle {{ fill:#2563eb; stroke:#fff; stroke-width:2; transition:stroke .15s ease, stroke-width .15s ease; }}
-.focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle {{ stroke:#0f172a; stroke-width:3; }}
+.focused-graph-node circle {{ fill:#3b82f6; stroke:#e2e8f0; stroke-width:2; transition:stroke .15s ease, stroke-width .15s ease; }}
+.focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle {{ stroke:#f8fafc; stroke-width:3; }}
 .focused-graph-node.search-match circle {{ stroke:#f59e0b; stroke-width:3; }}
 .focused-graph-node.dimmed {{ opacity:.18; }}
 .focused-graph-node.hidden {{ display:none; }}
-.focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed var(--line); border-radius:10px; background:#fff; color:var(--muted); }}
-.focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; }}
-.legend-item {{ display:inline-flex; gap:6px; align-items:center; color:var(--muted); font-size:13px; }}
-.legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid var(--line); flex:0 0 auto; }}
+.focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed #475569; border-radius:10px; background:#1e293b; color:#cbd5e1; }}
+.focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a; }}
+.legend-item {{ display:inline-flex; gap:6px; align-items:center; color:#cbd5e1; font-size:13px; }}
+.legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid #475569; flex:0 0 auto; }}
 .legend-line {{ width:28px; height:0; border-radius:0; border:0; border-top:2px solid var(--line); background:transparent; }}
 .legend-node {{ background:#2563eb; }}
 .legend-tree-link {{ border-top-color:#cbd5e1; border-top-width:1.4px; }}
@@ -991,19 +1005,52 @@ def visit(row: Any) -> str:
                 "type": row.get("kind") or "hierarchy",
             }
             for key in (
+                "name",
                 "feature_name",
                 "feature_path",
                 "path",
+                "module",
+                "file",
+                "symbol",
+                "dep_node_id",
+                "type",
                 "node_type",
+                "signature",
                 "mapping_status",
+                "locate_status",
+                "breadcrumb",
+                "breadcrumb_path",
+                "score",
+                "source",
+                "source_graph",
+                "edge_source",
+                "relation_source",
+                "source_feature",
+                "source_features",
+                "relation",
+                "direction",
+                "reason",
+                "line_range",
+                "apply_action",
                 "mapped_code",
+                "mapped_code_node_ids",
+                "mapped_code_link_ids",
                 "mapped_code_path",
                 "mapped_code_paths",
                 "mapped_code_symbol",
                 "mapped_code_symbols",
                 "mapped_code_count",
+                "mapped_rpg_node_ids",
+                "mapped_rpg_link_ids",
+                "changed",
                 "changed_files",
+                "affected_files",
                 "diff_anchor",
+                "diff",
+                "hidden_counts",
+                "warning_types",
+                "rpg_node_id",
+                "neighbor_node_id",
             ):
                 value = row.get(key) if row.get(key) not in (None, "") else metadata.get(key)
                 if value not in (None, ""):
@@ -1300,6 +1347,7 @@ def _focused_graph_runtime() -> str:
   const svg = section.querySelector('[data-focused-graph-svg]');
   const fallback = section.querySelector('[data-focused-graph-fallback]');
   const statusEl = section.querySelector('[data-focused-graph-status]');
+  const detailEl = section.querySelector('[data-focused-graph-detail]');
   if (!window.d3 || !dataEl || !svg) return;
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
@@ -1309,6 +1357,14 @@ def _focused_graph_runtime() -> str:
   const defaultShowEdges = defaultFocus.show_edges !== false;
   const text = value => value === undefined || value === null ? '' : String(value);
   const list = value => Array.isArray(value) ? value : [];
+  const nodePayloadById = {};
+  list(data.nodes).forEach(node => {
+    if (!node || typeof node !== 'object') return;
+    const id = text(node.id);
+    const nodeId = text(node.node_id || node.dep_node_id);
+    if (id) nodePayloadById[id] = node;
+    if (nodeId && !nodePayloadById[nodeId]) nodePayloadById[nodeId] = node;
+  });
   const root = d3.hierarchy(data.hierarchy || {id:'focused-graph-root', name:'Focused graph', children:[]}, d => d.children);
   const rootHierarchyId = text(root.data.id || 'focused-graph-root');
   const focusedNodeIds = new Set(list(defaultFocus.focused_tree_node_ids || defaultFocus.focused_node_ids || defaultFocus.node_link_ids).map(text).filter(Boolean));
@@ -1365,30 +1421,168 @@ def _focused_graph_runtime() -> str:
   svgSelection.call(zoom).on('dblclick.zoom', null).on('click', event => {
     if (event.target === svg) {
       selectedId = null;
+      renderFocusedGraphDetail(null);
       update(root);
     }
   });
 
-  function mappedCodeLabel(d) {
-    const path = d.data.mapped_code_path || list(d.data.mapped_code_paths)[0] || '';
-    const symbol = d.data.mapped_code_symbol || list(d.data.mapped_code_symbols)[0] || '';
-    return [path, symbol].filter(Boolean).join(' · ');
+  function nodeDetailData(d) {
+    if (!d) return {};
+    const data = d.data || {};
+    const payload = nodePayloadById[text(d.id)] || nodePayloadById[text(data.node_id || data.dep_node_id)] || {};
+    return {...payload, ...data};
   }
 
   function nodeLabel(d) {
-    const base = text(d.data.label || d.data.feature_name || d.data.name || d.data.node_id || d.id);
-    const mapped = mappedCodeLabel(d);
-    return mapped && !base.includes(mapped) ? `${base} — ${mapped}` : base;
+    const detail = nodeDetailData(d);
+    return text(detail.feature_name || detail.name || detail.node_id || detail.dep_node_id || detail.id || d.id || 'node');
+  }
+
+  function searchText(value) {
+    if (Array.isArray(value)) return value.map(searchText).join(' ');
+    if (value && typeof value === 'object') return Object.values(value).map(searchText).join(' ');
+    return text(value);
   }
 
   function nodeSearchText(d) {
-    return `${nodeLabel(d)} ${d.data.node_id || ''} ${d.data.feature_path || ''} ${d.data.path || ''} ${d.data.mapped_code_path || ''} ${list(d.data.mapped_code_paths).join(' ')} ${d.data.mapped_code_symbol || ''} ${list(d.data.mapped_code_symbols).join(' ')}`.toLowerCase();
+    return `${nodeLabel(d)} ${searchText(nodeDetailData(d))}`.toLowerCase();
   }
 
   function nodeMatches(d) {
     return query && nodeSearchText(d).includes(query);
   }
 
+  function isPresent(value) {
+    if (value === undefined || value === null || value === '') return false;
+    if (Array.isArray(value)) return value.length > 0;
+    return true;
+  }
+
+  function escapeHtml(value) {
+    return text(value).replace(/[&<>"']/g, char => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;', "'":'&#39;'}[char]));
+  }
+
+  function uniqueTexts(values) {
+    const seen = new Set();
+    const result = [];
+    values.forEach(value => {
+      const item = text(value).trim();
+      if (!item || seen.has(item)) return;
+      seen.add(item);
+      result.push(item);
+    });
+    return result;
+  }
+
+  function detailItems(value) {
+    if (!isPresent(value)) return [];
+    return Array.isArray(value) ? value : [value];
+  }
+
+  function lineRangeText(value) {
+    if (!isPresent(value)) return '';
+    if (Array.isArray(value)) return value.map(text).filter(Boolean).join('-');
+    if (value && typeof value === 'object') {
+      const start = value.start ?? value.start_line ?? value.line_start;
+      const end = value.end ?? value.end_line ?? value.line_end;
+      if (isPresent(start) && isPresent(end)) return `${start}-${end}`;
+      return searchText(value).trim();
+    }
+    return text(value);
+  }
+
+  function simpleValueHtml(value) {
+    if (!isPresent(value)) return '';
+    if (Array.isArray(value)) return detailListHtml(value, simpleValueHtml);
+    if (value && typeof value === 'object') return `<code>${escapeHtml(searchText(value).trim() || JSON.stringify(value))}</code>`;
+    return escapeHtml(value);
+  }
+
+  function detailListHtml(value, render) {
+    const rows = detailItems(value).map(render).filter(Boolean);
+    return rows.length ? `<ul class="focused-graph-detail-list">${rows.map(row => `<li>${row}</li>`).join('')}</ul>` : '';
+  }
+
+  function changedFilesHtml(value) {
+    return detailListHtml(value, item => {
+      if (item && typeof item === 'object') {
+        const label = text(item.path || item.file || item.diff_anchor || item.href);
+        const href = text(item.href || (item.diff_anchor ? `#${item.diff_anchor}` : ''));
+        if (!label) return '';
+        return href ? `<a href="${escapeHtml(href)}">${escapeHtml(label)}</a>` : escapeHtml(label);
+      }
+      return escapeHtml(item);
+    });
+  }
+
+  function diffHtml(value, detail) {
+    if (value && typeof value === 'object') {
+      const label = text(value.path || value.href || 'View diff');
+      const href = text(value.href || (value.diff_anchor ? `#${value.diff_anchor}` : ''));
+      return href ? `<a href="${escapeHtml(href)}">${escapeHtml(label)}</a>` : escapeHtml(label);
+    }
+    if (detail.diff_anchor) return `<a href="#${escapeHtml(detail.diff_anchor)}">${escapeHtml(detail.path || detail.diff_anchor)}</a>`;
+    return '';
+  }
+
+  function mappedCodeHtml(value, detail) {
+    let refs = detailItems(value);
+    if (!refs.length) {
+      const paths = list(detail.mapped_code_paths);
+      const symbols = list(detail.mapped_code_symbols);
+      if (paths.length || symbols.length || detail.mapped_code_path || detail.mapped_code_symbol) {
+        refs = [{path: detail.mapped_code_path || paths[0], symbol: detail.mapped_code_symbol || symbols[0]}];
+      }
+    }
+    return detailListHtml(refs, item => {
+      if (item && typeof item === 'object') {
+        const label = uniqueTexts([item.path, item.symbol, item.node_id || item.link_id]).join(' · ');
+        const meta = uniqueTexts([item.type || item.kind, lineRangeText(item.line_range), item.source]).join(' · ');
+        if (!label && !meta) return '';
+        return `${escapeHtml(label || meta)}${label && meta ? `<span>${escapeHtml(meta)}</span>` : ''}`;
+      }
+      return escapeHtml(item);
+    });
+  }
+
+  function addValueRow(rows, label, value) {
+    if (!isPresent(value)) return;
+    rows.push(`<div class="focused-graph-detail-row"><dt>${escapeHtml(label)}</dt><dd>${simpleValueHtml(value)}</dd></div>`);
+  }
+
+  function addHtmlRow(rows, label, value) {
+    if (!value) return;
+    rows.push(`<div class="focused-graph-detail-row"><dt>${escapeHtml(label)}</dt><dd>${value}</dd></div>`);
+  }
+
+  function renderFocusedGraphDetail(d) {
+    if (!detailEl) return;
+    if (!d) {
+      detailEl.innerHTML = '<h3>Node details</h3><p class="empty">Select a node to inspect metadata.</p>';
+      return;
+    }
+    const detail = nodeDetailData(d);
+    const rows = [];
+    const typeText = uniqueTexts([detail.node_type || detail.type || detail.kind, detail.state, detail.mapping_status, detail.locate_status]).join(' · ');
+    const relationText = uniqueTexts([detail.relation, detail.direction]).join(' · ');
+    const sourceText = uniqueTexts([detail.source, detail.source_graph, detail.edge_source, detail.relation_source]).join(' · ');
+    addValueRow(rows, 'Node id', detail.node_id || detail.dep_node_id || detail.id);
+    addValueRow(rows, 'Feature path', detail.feature_path || detail.breadcrumb_path || detail.breadcrumb);
+    addValueRow(rows, 'Path', detail.path || detail.module || detail.file);
+    addValueRow(rows, 'Symbol', detail.symbol);
+    addValueRow(rows, 'Type', typeText);
+    addValueRow(rows, 'Relation', relationText);
+    addValueRow(rows, 'Source', sourceText);
+    addValueRow(rows, 'Reason', detail.reason);
+    addValueRow(rows, 'Lines', lineRangeText(detail.line_range));
+    addHtmlRow(rows, 'Mapped code', mappedCodeHtml(detail.mapped_code, detail));
+    addHtmlRow(rows, 'Changed files', changedFilesHtml(detail.changed_files || detail.affected_files));
+    addHtmlRow(rows, 'Diff', diffHtml(detail.diff, detail));
+    const chips = uniqueTexts([detail.kind, detail.state, detail.mapping_status, detail.source]).map(item => `<span class="badge">${escapeHtml(item)}</span>`).join('');
+    const body = rows.length ? `<dl>${rows.join('')}</dl>` : '<p class="empty">No additional metadata for this node.</p>';
+    detailEl.innerHTML = `<h3>${escapeHtml(nodeLabel(d))}</h3>${chips ? `<div class="focused-graph-detail-badges">${chips}</div>` : ''}${body}`;
+  }
+
   function diagonal(s, d) {
     return `M${s.y},${s.x} C${(s.y + d.y) / 2},${s.x} ${(s.y + d.y) / 2},${d.x} ${d.y},${d.x}`;
   }
@@ -1436,6 +1630,7 @@ def _focused_graph_runtime() -> str:
     if (search) search.value = '';
     const edges = section.querySelector('[data-action="edges"]');
     if (edges) edges.checked = showEdges;
+    renderFocusedGraphDetail(null);
     svgSelection.transition().duration(150).call(zoom.transform, d3.zoomIdentity.translate(80, 40));
     update(root);
   }
@@ -1528,6 +1723,7 @@ def _focused_graph_runtime() -> str:
       .on('click', (event, d) => {
         event.stopPropagation();
         selectedId = selectedId === d.id ? null : d.id;
+        renderFocusedGraphDetail(selectedId ? d : null);
         update(d);
       })
       .on('dblclick', (event, d) => {
@@ -1542,9 +1738,12 @@ def _focused_graph_runtime() -> str:
       .attr('x', d => d.children || d._children ? -10 : 10)
       .attr('text-anchor', d => d.children || d._children ? 'end' : 'start')
       .attr('font-size', 12)
-      .attr('fill', '#1f2937')
+      .attr('fill', '#e5e7eb')
       .text(d => nodeLabel(d).length > 46 ? nodeLabel(d).slice(0, 44) + '…' : nodeLabel(d));
-    nodeEnter.append('title').text(d => `${nodeLabel(d)}\n${d.data.feature_path || ''}\n${d.data.mapped_code_path || ''} ${d.data.mapped_code_symbol || ''}`);
+    nodeEnter.append('title').text(d => {
+      const detail = nodeDetailData(d);
+      return `${nodeLabel(d)}\n${detail.feature_path || ''}\n${detail.path || ''} ${detail.symbol || ''}`;
+    });
 
     const nodeUpdate = nodeEnter.merge(node);
     nodeUpdate.transition().duration(250).attr('transform', d => `translate(${d.y},${d.x})`);
@@ -1568,6 +1767,7 @@ def _focused_graph_runtime() -> str:
       .remove();
 
     drawRelationEdges();
+    renderFocusedGraphDetail(selectedId ? (nodeById[selectedId] || allNodeById[selectedId]) : null);
     currentNodes.forEach(d => { d.x0 = d.x; d.y0 = d.y; });
   }
 
@@ -1640,6 +1840,7 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         f"<script type=\"application/json\" data-focused-graph-json>{graph_json}</script>"
         '<div class="focused-graph-stage">'
         '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="520"></svg>'
+        '<aside class="focused-graph-detail" data-focused-graph-detail aria-live="polite"><h3>Node details</h3><p class="empty">Select a node to inspect metadata.</p></aside>'
         f'<div class="focused-graph-fallback" data-focused-graph-fallback{fallback_hidden}>Static focused graph fallback is available when D3 cannot run.{d3_missing_note}</div>'
         '</div>'
         f"{warnings_html}{hidden_html}"
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 741422a..6c8fb53 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -25,7 +25,7 @@
 from common.run_report import write_command_report
 
 
-def test_run_report_exposes_current_impact_renderers_only() -> None:
+def test_common_run_report_run_report_exposes_current_impact_renderers_only() -> None:
     assert hasattr(run_report, "_render_focused_graph")
     assert hasattr(run_report, "_inline_d3")
     assert not hasattr(run_report, "_render_semantic_code_impact_chain")
@@ -36,7 +36,7 @@ def test_run_report_exposes_current_impact_renderers_only() -> None:
     assert not hasattr(run_report, "_render_focused_impact_group")
 
 
-def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_escapes_content_and_writes_sections(tmp_path: Path) -> None:
     report = write_command_report(
         CommandRun(
             command="rpg/edit <script>alert(1)</script>",
@@ -108,7 +108,7 @@ def test_write_command_report_escapes_content_and_writes_sections(tmp_path: Path
     assert "backup/<script>" not in html
 
 
-def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_renders_retrievals_code_deltas_and_focused_view(tmp_path: Path) -> None:
     long_diff = "diff --git a/a.py b/a.py\n" + "\n".join(
         f"+line {i} <script>alert({i})</script>" for i in range(40)
     )
@@ -380,6 +380,10 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "data-action=\"edges\"" in html
     assert "data-action=\"search\"" in html
     assert "data-focused-graph-status" in html
+    assert "data-focused-graph-detail" in html
+    assert '<aside class="focused-graph-detail" data-focused-graph-detail aria-live="polite">' in html
+    assert "Node details" in html
+    assert "Select a node to inspect metadata." in html
     assert "Visible relation edges: 0/3" in html
     assert "Reset" in html
     assert "+1" in html
@@ -393,6 +397,11 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
+    assert ".focused-graph-stage { border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
+    assert ".focused-graph-toolbar { display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
+    assert ".focused-graph-toolbar button, .focused-graph-toolbar input { border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb;" in html
+    assert ".focused-graph-legend { display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
+    assert ".focused-graph-detail { position:absolute; top:14px; right:14px;" in html
     assert "rootHierarchyId" in html
     assert "defaultExpandedIds" in html
     assert "visibleEndpoint" in html
@@ -400,6 +409,16 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "const visible = showEdges ? currentRelationEdges.length : 0;" in html
     assert "const total = relationEdges.length;" in html
     assert "statusEl.textContent = `Visible relation edges: ${visible}/${total}`;" in html
+    assert "const detailEl = section.querySelector('[data-focused-graph-detail]');" in html
+    assert "function nodeDetailData(d)" in html
+    assert "function renderFocusedGraphDetail(d)" in html
+    assert "function searchText(value)" in html
+    assert "return `${nodeLabel(d)} ${searchText(nodeDetailData(d))}`.toLowerCase();" in html
+    assert "renderFocusedGraphDetail(null);" in html
+    assert "renderFocusedGraphDetail(selectedId ? d : null);" in html
+    assert "return text(detail.feature_name || detail.name || detail.node_id || detail.dep_node_id || detail.id || d.id || 'node');" in html
+    assert "function mappedCodeLabel" not in html
+    assert "return mapped && !base.includes(mapped)" not in html
     assert "expandDepth" in html
     assert "collapseDepth" in html
     assert "Expand hierarchy depth" in html
@@ -457,6 +476,20 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert graph_payload["summary"]["context_edges"] == 3
     relation_links = [link for link in graph_payload["links"] if link.get("relation") != "contains"]
     assert len(relation_links) == 3
+    nodes_by_id = {node["id"]: node for node in graph_payload["nodes"]}
+    assert nodes_by_id["rpg-n1-script"]["symbol"] == "NodeSymbol <unsafe>"
+    assert nodes_by_id["rpg-n1-script"]["reason"] == "selected <reason>"
+    assert nodes_by_id["rpg-n1-script"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
+    assert nodes_by_id["rpg-n1-script"]["diff"] == {"path": "a.py", "href": "#diff-a.py"}
+    assert nodes_by_id["code-a.py-f-script"]["symbol"] == "func <unsafe>"
+    assert nodes_by_id["code-a.py-f-script"]["line_range"] == {"start": 10, "end": 12}
+    assert nodes_by_id["code-a.py-f-script"]["source"] == "locate<unsafe>"
+    assert nodes_by_id["context-caller-script"]["relation"] == "caller"
+    assert nodes_by_id["context-caller-script"]["direction"] == "upstream"
+    assert nodes_by_id["context-caller-script"]["source"] == "impact"
+    assert nodes_by_id["context-caller-script"]["reason"] == "calls <reason>"
+    assert nodes_by_id["context-imported-script"]["relation"] == "imports"
+    assert nodes_by_id["context-imported-script"]["source_graph"] == "dep_graph"
     assert any(node["id"] == "context-callee-script" for node in graph_payload["nodes"])
     assert any(node["id"] == "context-imported-script" for node in graph_payload["nodes"])
     assert any("context-callee-script" in edge["target_candidates"] for edge in graph_payload["relation_edges"])
@@ -490,7 +523,7 @@ def test_write_command_report_renders_retrievals_code_deltas_and_focused_view(tm
     assert "Inspector metadata" not in html
 
 
-def test_write_command_report_renders_static_fallback_without_d3(tmp_path: Path, monkeypatch) -> None:
+def test_common_run_report_write_command_report_renders_static_fallback_without_d3(tmp_path: Path, monkeypatch) -> None:
     monkeypatch.setattr(run_report, "_D3_ASSET", tmp_path / "missing-d3.v7.min.js")
 
     report = write_command_report(
@@ -519,7 +552,7 @@ def test_write_command_report_renders_static_fallback_without_d3(tmp_path: Path,
     assert "Static focused graph fallback is available when D3 cannot run." in html
 
 
-def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
     report = write_command_report(
         CommandRun(
             command="encode",
@@ -538,7 +571,7 @@ def test_write_command_report_limits_summary_cards(tmp_path: Path) -> None:
     assert "card-8" not in visible_cards
 
 
-def test_write_command_report_preserves_same_timestamp_runs(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_preserves_same_timestamp_runs(tmp_path: Path) -> None:
     first = write_command_report(CommandRun("update_rpg", timestamp="fixed"), report_dir=tmp_path)
     second = write_command_report(CommandRun("update_rpg", timestamp="fixed"), report_dir=tmp_path)
 
@@ -549,7 +582,7 @@ def test_write_command_report_preserves_same_timestamp_runs(tmp_path: Path) -> N
     assert second.exists()
 
 
-def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Path) -> None:
     report = write_command_report(
         CommandRun(
             command="encode",
@@ -567,7 +600,7 @@ def test_write_command_report_does_not_invent_node_rows_from_counts(tmp_path: Pa
     assert '<td><code>4</code></td>' not in html
 
 
-def test_write_command_report_infers_artifact_status_and_preserves_verification_detail(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_infers_artifact_status_and_preserves_verification_detail(tmp_path: Path) -> None:
     available = tmp_path / "available.json"
     available.write_text("{}", encoding="utf-8")
     missing = tmp_path / "missing.json"
@@ -603,7 +636,7 @@ def test_write_command_report_infers_artifact_status_and_preserves_verification_
     assert "<td>from reason</td>" not in html
 
 
-def test_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:
+def test_common_run_report_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:
     available = tmp_path / "artifact.txt"
     available.write_text("ok", encoding="utf-8")
 
@@ -647,7 +680,7 @@ def test_all_event_types_serialize_with_optional_fields(tmp_path: Path) -> None:
     assert run["artifacts"][0]["status"] == "available"
 
 
-def test_write_command_report_accepts_command_run_mapping(tmp_path: Path) -> None:
+def test_common_run_report_write_command_report_accepts_command_run_mapping(tmp_path: Path) -> None:
     run = CommandRun(
         command="mapping",
         summary=[{"label": "safe", "value": "<ok>"}],

From 6da52972c046eff2c181e85e499840b33a4df234 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 10:56:07 +0000
Subject: [PATCH 41/56] rpg_edit: Enhance `_build_update_focus()` at
 scripts/update_graphs.py:

---
 CoderMind/scripts/update_graphs.py      | 729 ++++++++++++++++++++++--
 CoderMind/tests/test_encode_commands.py |  67 ++-
 2 files changed, 760 insertions(+), 36 deletions(-)

diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index f2e5a77..a397e27 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -23,6 +23,7 @@
 import argparse
 import json
 import os
+import re
 import sys
 import time
 from pathlib import Path
@@ -346,11 +347,651 @@ def _dep_node_matches_file(dep_id: str, attrs: dict[str, Any], file_path: str) -
     return False
 
 
+def _slug_id(prefix: str, value: Any) -> str:
+    raw = str(value or prefix)
+    slug = re.sub(r"[^A-Za-z0-9_.-]+", "-", raw).strip(".-_")
+    return f"{prefix}-{slug or 'node'}"
+
+
+def _node_link_id(kind: str, node_id: Any) -> str:
+    return _slug_id(kind, node_id)
+
+
+def _set_if_present(row: dict[str, Any], key: str, value: Any) -> None:
+    if value not in (None, ""):
+        row[key] = value
+
+
+def _code_delta_file(delta: dict[str, Any]) -> str:
+    return str(delta.get("file") or delta.get("path") or delta.get("after") or delta.get("before") or "")
+
+
+def _diff_anchor_slug(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", value).strip("._-") or "change"
+
+
+def _diff_anchor_map(code_deltas: list[dict[str, Any]]) -> dict[str, str]:
+    anchors: dict[str, str] = {}
+    used: dict[str, int] = {}
+    for index, delta in enumerate(code_deltas, start=1):
+        file_path = _code_delta_file(delta) or f"change-{index}"
+        base = _diff_anchor_slug(f"diff-{file_path}")
+        count = used.get(base, 0) + 1
+        used[base] = count
+        if file_path not in anchors:
+            anchors[file_path] = base if count == 1 else f"{base}-{count}"
+    return anchors
+
+
+def _changed_file_refs(files: list[Any], anchors: dict[str, str]) -> list[dict[str, Any]]:
+    refs: list[dict[str, Any]] = []
+    for file_path in _ordered_unique_text(files):
+        row: dict[str, Any] = {"path": file_path}
+        _set_if_present(row, "diff_anchor", anchors.get(file_path))
+        refs.append(row)
+    return refs
+
+
+def _node_state(row: dict[str, Any], default: str = "available") -> str:
+    status = row.get("state") or row.get("status") or row.get("mapping_status")
+    if status in (None, ""):
+        return default
+    if status == "missing":
+        return "missing_mapping"
+    return str(status)
+
+
+def _line_range_from(row: dict[str, Any]) -> dict[str, Any]:
+    start = row.get("start_line") or row.get("lineno") or row.get("line") or row.get("start")
+    end = row.get("end_line") or row.get("end") or start
+    if start in (None, ""):
+        return {}
+    return {"start": start, "end": end}
+
+
+def _symbol_from_dep(dep_id: str, attrs: dict[str, Any]) -> str:
+    for key in ("symbol", "name", "qualname"):
+        value = attrs.get(key)
+        if value not in (None, ""):
+            return str(value)
+    if ":" in dep_id:
+        return dep_id.rsplit(":", 1)[-1]
+    path = attrs.get("path") or attrs.get("file") or dep_id
+    return Path(str(path)).name
+
+
+def _edge_endpoint_link_id(node_id: Any, rpg_nodes: dict[str, dict[str, Any]], code_nodes: dict[str, dict[str, Any]]) -> str:
+    node_text = str(node_id or "")
+    if node_text in rpg_nodes:
+        return str(rpg_nodes[node_text].get("link_id") or _node_link_id("rpg", node_text))
+    if node_text in code_nodes:
+        return str(code_nodes[node_text].get("link_id") or _node_link_id("code", node_text))
+    return _node_link_id("context", node_text)
+
+
+def _warning_link_fields(warning: dict[str, Any], rpg_nodes: dict[str, dict[str, Any]], code_nodes: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    row = dict(warning)
+    node_id = warning.get("node_id") or warning.get("rpg_node_id")
+    dep_id = warning.get("dep_node_id") or warning.get("code_node_id")
+    if node_id not in (None, "") and str(node_id) in rpg_nodes:
+        row["node_link_id"] = _edge_endpoint_link_id(node_id, rpg_nodes, code_nodes)
+    if dep_id not in (None, "") and str(dep_id) in code_nodes:
+        row["code_link_id"] = _edge_endpoint_link_id(dep_id, rpg_nodes, code_nodes)
+    return row
+
+
+def _hierarchy_segments(value: Any) -> list[str]:
+    if isinstance(value, (list, tuple)):
+        return [str(item) for item in value if item not in (None, "")]
+    if value in (None, ""):
+        return []
+    text = str(value)
+    separator = " / " if " / " in text else "/"
+    return [part.strip() for part in text.split(separator) if part.strip()]
+
+
+def _hierarchy_child(parent: dict[str, Any], child_id: str, name: str, kind: str) -> dict[str, Any]:
+    children = parent.setdefault("children", [])
+    for child in children:
+        if isinstance(child, dict) and child.get("id") == child_id:
+            return child
+    child = {"id": child_id, "name": name, "kind": kind, "children": []}
+    children.append(child)
+    return child
+
+
+def _append_hierarchy_leaf(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
+    children = parent.setdefault("children", [])
+    leaf_id = leaf.get("id")
+    if any(isinstance(child, dict) and child.get("id") == leaf_id for child in children):
+        return
+    children.append(leaf)
+
+
+def _semantic_hierarchy_parts(node: dict[str, Any]) -> list[str]:
+    for key in ("breadcrumb", "breadcrumb_path", "feature_path", "path"):
+        parts = _hierarchy_segments(node.get(key))
+        if parts:
+            return parts[:-1] if len(parts) > 1 else []
+    return []
+
+
+def _focused_graph_hierarchy(
+    semantic_nodes: list[dict[str, Any]],
+    code_nodes: list[dict[str, Any]],
+    mappings: list[dict[str, Any]],
+    edges: list[dict[str, Any]],
+    hidden_counts: dict[str, Any],
+    warnings: list[dict[str, Any]],
+) -> dict[str, Any]:
+    root: dict[str, Any] = {
+        "id": "focused-graph-root",
+        "name": "Focused graph",
+        "kind": "root",
+        "feature_name": "Focused graph",
+        "feature_path": "Focused graph",
+        "meta": {"hidden_counts": hidden_counts, "warnings": len(warnings), "edges": len(edges)},
+        "children": [],
+    }
+    attached_endpoint_ids: set[str] = set()
+    code_by_id = {
+        str(node.get("node_id") or node.get("dep_node_id")): node
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+
+    def feature_path_text(node: dict[str, Any], group_parts: list[str], feature_name: str) -> str:
+        for key in ("feature_path", "breadcrumb_path", "breadcrumb", "path"):
+            parts = _hierarchy_segments(node.get(key))
+            if parts:
+                return " / ".join(parts)
+        return " / ".join(group_parts + ([feature_name] if feature_name else []))
+
+    def endpoint_group(parent: dict[str, Any], owner_id: str, name: str, kind: str) -> dict[str, Any]:
+        return _hierarchy_child(parent, _node_link_id(kind, owner_id), name, kind)
+
+    def make_code_leaf(ref: dict[str, Any]) -> dict[str, Any]:
+        code_id = str(ref.get("node_id") or ref.get("dep_node_id") or "")
+        code = code_by_id.get(code_id, {})
+        path = ref.get("path") or code.get("path") or code.get("file") or code.get("module") or _dep_node_path(code_id, code)
+        symbol = ref.get("symbol") or ref.get("name") or code.get("symbol") or code.get("name") or _symbol_from_dep(code_id, code)
+        leaf: dict[str, Any] = {
+            "id": str(ref.get("link_id") or code.get("link_id") or _node_link_id("code", code_id)),
+            "node_id": code_id,
+            "dep_node_id": code_id,
+            "name": symbol or path or code_id,
+            "symbol": symbol,
+            "path": path,
+            "kind": "code",
+            "state": ref.get("state") or code.get("state") or _node_state(code, "mapped"),
+            "aliases": _ordered_unique_text([code_id, ref.get("link_id"), code.get("link_id")]),
+        }
+        for key in ("type", "line_range", "source", "changed", "changed_files", "diff_anchor"):
+            _set_if_present(leaf, key, ref.get(key) or code.get(key))
+        return leaf
+
+    def append_endpoint(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
+        leaf_id = str(leaf.get("id") or "")
+        if not leaf_id or leaf_id in attached_endpoint_ids:
+            return
+        attached_endpoint_ids.add(leaf_id)
+        _append_hierarchy_leaf(parent, leaf)
+
+    for node in semantic_nodes:
+        node_id = str(node.get("node_id") or "")
+        if not node_id:
+            continue
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node_id))
+        feature_name = str(node.get("name") or node.get("symbol") or node_id or "feature")
+        group_parts = _semantic_hierarchy_parts(node)
+        parent = root
+        trail: list[str] = []
+        for part in group_parts:
+            trail.append(part)
+            group = _hierarchy_child(parent, _node_link_id("feature-path", "/".join(trail)), part, "feature_group")
+            group["feature_name"] = part
+            group["feature_path"] = " / ".join(trail)
+            parent = group
+        leaf: dict[str, Any] = {
+            "id": link_id,
+            "node_id": node_id,
+            "name": feature_name,
+            "feature_name": feature_name,
+            "feature_path": feature_path_text(node, group_parts, feature_name),
+            "kind": "feature",
+            "state": node.get("state"),
+            "mapping_status": node.get("mapping_status"),
+        }
+        for key in (
+            "type",
+            "node_type",
+            "path",
+            "breadcrumb",
+            "breadcrumb_path",
+            "changed_files",
+            "hidden_counts",
+            "warning_types",
+            "source",
+            "mapped_code",
+            "mapped_code_node_ids",
+            "mapped_code_link_ids",
+            "mapped_code_paths",
+            "mapped_code_symbols",
+            "mapped_code_path",
+            "mapped_code_symbol",
+            "mapped_code_count",
+        ):
+            _set_if_present(leaf, key, node.get(key))
+        code_group: Optional[dict[str, Any]] = None
+        for ref in _listify(node.get("mapped_code")):
+            if not isinstance(ref, dict):
+                continue
+            if code_group is None:
+                code_group = endpoint_group(leaf, link_id, "Mapped code", "code_group")
+            append_endpoint(code_group, make_code_leaf(ref))
+        _append_hierarchy_leaf(parent, leaf)
+
+    root_code_group: Optional[dict[str, Any]] = None
+    for code in code_nodes:
+        code_id = str(code.get("node_id") or code.get("dep_node_id") or "")
+        if not code_id:
+            continue
+        leaf = make_code_leaf({"node_id": code_id, "link_id": code.get("link_id")})
+        if str(leaf.get("id") or "") in attached_endpoint_ids:
+            continue
+        if root_code_group is None:
+            root_code_group = endpoint_group(root, "unassigned", "Additional code context", "code_group")
+        append_endpoint(root_code_group, leaf)
+
+    root_context_group: Optional[dict[str, Any]] = None
+    known_links = {str(node.get("link_id") or "") for node in semantic_nodes + code_nodes}
+    for edge in edges:
+        for side in ("source", "target"):
+            link_id = str(edge.get(f"{side}_link_id") or "")
+            node_id = str(edge.get(f"{side}_node_id") or link_id)
+            if not link_id or link_id in known_links or link_id in attached_endpoint_ids:
+                continue
+            leaf = {
+                "id": link_id,
+                "node_id": node_id,
+                "name": edge.get("name") or edge.get("path") or node_id or "context",
+                "kind": "context",
+                "state": "context",
+                "relation": edge.get("relation"),
+                "source": edge.get("source") or edge.get("source_graph") or edge.get("edge_source"),
+                "aliases": _ordered_unique_text([node_id, link_id]),
+            }
+            for key in ("path", "reason", "source_graph", "edge_source", "relation_source"):
+                _set_if_present(leaf, key, edge.get(key))
+            if root_context_group is None:
+                root_context_group = endpoint_group(root, "unassigned", "Additional relation endpoints", "context_group")
+            append_endpoint(root_context_group, leaf)
+    return root
+
+
+def _focused_graph_default_focus(
+    semantic_nodes: list[dict[str, Any]],
+    code_nodes: list[dict[str, Any]],
+    mappings: list[dict[str, Any]],
+    edges: list[dict[str, Any]],
+    warnings: list[dict[str, Any]],
+) -> dict[str, Any]:
+    semantic_links = [str(node.get("link_id") or _node_link_id("rpg", node.get("node_id"))) for node in semantic_nodes]
+    code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
+    rpg_link_by_node_id = {
+        str(node.get("node_id")): str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        for node in semantic_nodes
+        if node.get("node_id") not in (None, "")
+    }
+    code_link_by_node_id = {
+        str(node.get("node_id") or node.get("dep_node_id")): str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        for node in code_nodes
+        if (node.get("node_id") or node.get("dep_node_id")) not in (None, "")
+    }
+    code_to_feature_links: dict[str, list[str]] = {}
+    hierarchy_paths_by_link: dict[str, list[str]] = {}
+
+    def remember_code_feature(code_link: Any, feature_link: Any) -> None:
+        if code_link in (None, "") or feature_link in (None, ""):
+            return
+        values = code_to_feature_links.setdefault(str(code_link), [])
+        feature_text = str(feature_link)
+        if feature_text not in values:
+            values.append(feature_text)
+
+    def remember_path(alias: Any, path_ids: list[str]) -> None:
+        if alias in (None, "") or not path_ids:
+            return
+        hierarchy_paths_by_link.setdefault(str(alias), path_ids)
+
+    semantic_path_ids_by_link: dict[str, list[str]] = {}
+    for node in semantic_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        trail: list[str] = []
+        path_ids: list[str] = ["focused-graph-root"]
+        for part in _semantic_hierarchy_parts(node):
+            trail.append(part)
+            path_ids.append(_node_link_id("feature-path", "/".join(trail)))
+        path_ids.append(link_id)
+        semantic_path_ids_by_link[link_id] = path_ids
+        remember_path(link_id, path_ids)
+        remember_path(node.get("node_id"), path_ids)
+
+    for mapping in mappings:
+        source = mapping.get("source_link_id") or rpg_link_by_node_id.get(str(mapping.get("rpg_node_id") or mapping.get("node_id") or ""))
+        target_node_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        target = mapping.get("target_link_id") or code_link_by_node_id.get(str(target_node_id or "")) or _node_link_id("code", target_node_id)
+        remember_code_feature(target, source)
+        remember_code_feature(target_node_id, source)
+    for node in code_nodes:
+        node_id = node.get("node_id") or node.get("dep_node_id")
+        code_link = str(node.get("link_id") or _node_link_id("code", node_id))
+        for rpg_link in _listify(node.get("mapped_rpg_link_ids")):
+            remember_code_feature(code_link, rpg_link)
+            remember_code_feature(node_id, rpg_link)
+
+    for code_id, code_link in code_link_by_node_id.items():
+        feature_links = code_to_feature_links.get(code_link) or code_to_feature_links.get(code_id) or []
+        if feature_links:
+            base_path = semantic_path_ids_by_link.get(str(feature_links[0]))
+            if base_path:
+                code_path = base_path + [_node_link_id("code_group", feature_links[0]), code_link]
+            else:
+                code_path = ["focused-graph-root", _node_link_id("code_group", "unassigned"), code_link]
+        else:
+            code_path = ["focused-graph-root", _node_link_id("code_group", "unassigned"), code_link]
+        remember_path(code_link, code_path)
+        remember_path(code_id, code_path)
+
+    endpoint_link_ids: list[Any] = []
+    context_link_ids: list[Any] = []
+    semantic_link_set = set(semantic_links)
+    code_link_set = set(code_links)
+    for edge in edges:
+        for side in ("source", "target"):
+            link_id = str(edge.get(f"{side}_link_id") or "")
+            node_id = edge.get(f"{side}_node_id")
+            if not link_id:
+                continue
+            endpoint_link_ids.append(link_id)
+            endpoint_link_ids.append(node_id)
+            if link_id in semantic_link_set or link_id in code_link_set or str(node_id or "") in code_link_by_node_id:
+                continue
+            context_link_ids.append(link_id)
+            context_path = ["focused-graph-root", _node_link_id("context_group", "unassigned"), link_id]
+            remember_path(link_id, context_path)
+            remember_path(node_id, context_path)
+
+    changed_feature_links: list[Any] = []
+    changed_code_links: list[str] = []
+    for node in code_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id")))
+        if node.get("changed") or node.get("changed_files") or node.get("diff_anchor"):
+            changed_code_links.append(link_id)
+            changed_feature_links.extend(_listify(node.get("mapped_rpg_link_ids")) + code_to_feature_links.get(link_id, []))
+    warning_links: list[Any] = []
+    for warning in warnings:
+        warning_links.extend(_listify(warning.get("node_link_id")) + _listify(warning.get("code_link_id")))
+    node_link_ids = _ordered_unique_text(semantic_links + changed_feature_links + changed_code_links + warning_links)
+    if not node_link_ids:
+        node_link_ids = _ordered_unique_text(semantic_links + code_links)
+
+    expanded_node_ids: list[Any] = ["focused-graph-root"]
+    focused_path_node_ids: list[Any] = []
+    focused_tree_node_ids: list[Any] = []
+    for link_id in node_link_ids:
+        path_ids = hierarchy_paths_by_link.get(str(link_id or ""))
+        if not path_ids:
+            continue
+        expanded_node_ids.extend(path_ids[:-1])
+        focused_path_node_ids.extend(path_ids)
+        focused_tree_node_ids.append(path_ids[-1])
+
+    return {
+        "node_link_ids": node_link_ids,
+        "focused_node_ids": node_link_ids,
+        "focused_tree_node_ids": _ordered_unique_text(focused_tree_node_ids),
+        "focused_code_link_ids": _ordered_unique_text(changed_code_links + [link_id for link_id in node_link_ids if link_id in code_link_set]),
+        "expanded_node_ids": _ordered_unique_text(expanded_node_ids),
+        "default_expanded_node_ids": _ordered_unique_text(expanded_node_ids),
+        "focused_path_node_ids": _ordered_unique_text(focused_path_node_ids),
+        "semantic_node_ids": _ordered_unique_text([node.get("node_id") for node in semantic_nodes]),
+        "code_node_ids": _ordered_unique_text([node.get("node_id") or node.get("dep_node_id") for node in code_nodes]),
+        "mapping_link_ids": _ordered_unique_text([mapping.get("link_id") for mapping in mappings]),
+        "edge_link_ids": _ordered_unique_text([edge.get("link_id") for edge in edges]),
+        "relation_endpoint_link_ids": _ordered_unique_text(endpoint_link_ids),
+        "context_node_ids": _ordered_unique_text(context_link_ids),
+        "edge_depth": 1,
+        "show_edges": True,
+    }
+
+
+def _focused_graph_metadata(
+    semantic_nodes: list[dict[str, Any]],
+    code_nodes: list[dict[str, Any]],
+    mappings: list[dict[str, Any]],
+    edges: list[dict[str, Any]],
+    hidden_counts: dict[str, Any],
+    warnings: list[dict[str, Any]],
+    graph_context: dict[str, Any],
+) -> dict[str, Any]:
+    focused_graph: dict[str, Any] = {
+        "schema": "cmind.focused_graph.v1",
+        "hierarchy": _focused_graph_hierarchy(semantic_nodes, code_nodes, mappings, edges, hidden_counts, warnings),
+        "default_focus": _focused_graph_default_focus(semantic_nodes, code_nodes, mappings, edges, warnings),
+    }
+    if graph_context:
+        focused_graph["graph_context"] = graph_context
+    if hidden_counts:
+        focused_graph["hidden_counts"] = hidden_counts
+    if warnings:
+        focused_graph["warning_count"] = len(warnings)
+    return focused_graph
+
+
+def _build_nodes_view(
+    primary_rpg_nodes: list[dict[str, Any]],
+    primary_code_nodes: list[dict[str, Any]],
+    mappings: list[dict[str, Any]],
+    edges: list[dict[str, Any]],
+    hidden_counts: dict[str, Any],
+    warnings: list[dict[str, Any]],
+    changed_files: list[str],
+    diff_anchors: dict[str, str],
+    graph_context: dict[str, Any],
+) -> dict[str, Any]:
+    rpg_by_id = {str(row.get("node_id")): row for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
+    code_by_id = {str(row.get("node_id") or row.get("dep_node_id")): row for row in primary_code_nodes if (row.get("node_id") or row.get("dep_node_id")) not in (None, "")}
+    code_ids_by_rpg: dict[str, list[str]] = {}
+    warnings_by_rpg: dict[str, list[dict[str, Any]]] = {}
+    warnings_by_code: dict[str, list[dict[str, Any]]] = {}
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        if rpg_id not in (None, "") and code_id not in (None, ""):
+            code_ids_by_rpg.setdefault(str(rpg_id), []).append(str(code_id))
+    for warning in warnings:
+        if not isinstance(warning, dict):
+            continue
+        rpg_id = warning.get("node_id") or warning.get("rpg_node_id")
+        code_id = warning.get("dep_node_id") or warning.get("code_node_id")
+        if rpg_id not in (None, ""):
+            warnings_by_rpg.setdefault(str(rpg_id), []).append(warning)
+        if code_id not in (None, ""):
+            warnings_by_code.setdefault(str(code_id), []).append(warning)
+
+    semantic_nodes: list[dict[str, Any]] = []
+    for node in primary_rpg_nodes:
+        node_id = str(node.get("node_id") or "")
+        row: dict[str, Any] = {
+            "node_id": node_id,
+            "link_id": node.get("link_id") or _node_link_id("rpg", node_id),
+            "state": _node_state(node),
+            "mapping_status": node.get("mapping_status") or node.get("status"),
+        }
+        for key in ("name", "symbol", "type", "node_type", "path", "feature_path", "breadcrumb", "breadcrumb_path", "change", "source"):
+            _set_if_present(row, key, node.get(key))
+        changed_refs = _changed_file_refs(_listify(node.get("changed_files")) or _listify(node.get("affected_files")), diff_anchors)
+        if changed_refs:
+            row["changed_files"] = changed_refs
+        mapped_code_ids = _ordered_unique_text(code_ids_by_rpg.get(node_id, []))
+        if mapped_code_ids:
+            mapped_code_refs: list[dict[str, Any]] = []
+            for code_id in mapped_code_ids:
+                code = code_by_id.get(code_id, {})
+                path = code.get("path") or code.get("file") or code.get("module") or _dep_node_path(code_id, code)
+                symbol = code.get("symbol") or code.get("name") or _symbol_from_dep(code_id, code)
+                ref: dict[str, Any] = {
+                    "node_id": code_id,
+                    "dep_node_id": code_id,
+                    "link_id": _edge_endpoint_link_id(code_id, rpg_by_id, code_by_id),
+                    "path": path,
+                    "symbol": symbol,
+                }
+                for key in ("type", "kind", "line_range", "state", "source", "diff_anchor"):
+                    _set_if_present(ref, key, code.get(key))
+                mapped_code_refs.append(ref)
+            row["mapped_code"] = mapped_code_refs
+            row["mapped_code_node_ids"] = mapped_code_ids
+            row["mapped_code_link_ids"] = [ref["link_id"] for ref in mapped_code_refs]
+            row["mapped_code_paths"] = _ordered_unique_text([ref.get("path") for ref in mapped_code_refs])
+            row["mapped_code_symbols"] = _ordered_unique_text([ref.get("symbol") for ref in mapped_code_refs])
+            if row["mapped_code_paths"]:
+                row["mapped_code_path"] = row["mapped_code_paths"][0]
+            if row["mapped_code_symbols"]:
+                row["mapped_code_symbol"] = row["mapped_code_symbols"][0]
+            row["mapped_code_count"] = len(mapped_code_refs)
+        if warnings_by_rpg.get(node_id):
+            row["warning_types"] = _ordered_unique_text([warning.get("type") for warning in warnings_by_rpg[node_id]])
+        semantic_nodes.append(row)
+
+    code_nodes: list[dict[str, Any]] = []
+    for node in primary_code_nodes:
+        code_id = str(node.get("node_id") or node.get("dep_node_id") or "")
+        path = node.get("path") or _dep_node_path(code_id, node)
+        row: dict[str, Any] = {
+            "node_id": code_id,
+            "dep_node_id": code_id,
+            "link_id": node.get("link_id") or _node_link_id("code", code_id),
+            "state": _node_state(node, "mapped"),
+        }
+        for key in ("name", "symbol", "type", "kind", "path", "module", "file", "signature", "source", "change"):
+            _set_if_present(row, key, node.get(key))
+        _set_if_present(row, "path", path)
+        line_range = node.get("line_range") if isinstance(node.get("line_range"), dict) else _line_range_from(node)
+        if line_range:
+            row["line_range"] = line_range
+        changed_refs = _changed_file_refs(_listify(node.get("changed_files")) or ([path] if path in diff_anchors else []), diff_anchors)
+        if changed_refs:
+            row["changed"] = True
+            row["changed_files"] = changed_refs
+            row["diff_anchor"] = changed_refs[0].get("diff_anchor")
+        rpg_ids = _ordered_unique_text(
+            _listify(node.get("mapped_rpg_node_ids"))
+            + [mapping.get("rpg_node_id") for mapping in mappings if (mapping.get("code_node_id") or mapping.get("dep_node_id")) == code_id]
+        )
+        if rpg_ids:
+            mapped_rpg_refs: list[dict[str, Any]] = []
+            for rpg_id in rpg_ids:
+                rpg = rpg_by_id.get(rpg_id, {})
+                ref: dict[str, Any] = {
+                    "node_id": rpg_id,
+                    "link_id": _edge_endpoint_link_id(rpg_id, rpg_by_id, code_by_id),
+                    "name": rpg.get("name") or rpg_id,
+                }
+                for key in ("type", "node_type", "path", "feature_path", "breadcrumb_path", "state", "source"):
+                    _set_if_present(ref, key, rpg.get(key))
+                mapped_rpg_refs.append(ref)
+            row["mapped_rpg"] = mapped_rpg_refs
+            row["mapped_rpg_node_ids"] = rpg_ids
+            row["mapped_rpg_link_ids"] = [ref["link_id"] for ref in mapped_rpg_refs]
+        if warnings_by_code.get(code_id):
+            row["warning_types"] = _ordered_unique_text([warning.get("type") for warning in warnings_by_code[code_id]])
+        code_nodes.append(row)
+
+    mapping_rows: list[dict[str, Any]] = []
+    for mapping in mappings:
+        rpg_id = mapping.get("rpg_node_id") or mapping.get("node_id")
+        code_id = mapping.get("code_node_id") or mapping.get("dep_node_id")
+        row: dict[str, Any] = {
+            "link_id": _node_link_id("map", f"{rpg_id}-{code_id or 'missing'}"),
+            "rpg_node_id": rpg_id,
+            "source_link_id": _edge_endpoint_link_id(rpg_id, rpg_by_id, code_by_id),
+            "status": mapping.get("status") or "mapped",
+            "state": _node_state(mapping, "mapped"),
+        }
+        if code_id not in (None, ""):
+            row["code_node_id"] = code_id
+            row["dep_node_id"] = code_id
+            row["target_link_id"] = _edge_endpoint_link_id(code_id, rpg_by_id, code_by_id)
+        else:
+            row["target_state"] = "missing_mapping"
+        for key in ("source", "path", "reason"):
+            _set_if_present(row, key, mapping.get(key))
+        changed_refs = _changed_file_refs(_listify(mapping.get("changed_files")), diff_anchors)
+        if changed_refs:
+            row["changed_files"] = changed_refs
+        mapping_rows.append(row)
+
+    edge_rows: list[dict[str, Any]] = []
+    for edge in edges:
+        source_id = edge.get("source_node_id")
+        target_id = edge.get("target_node_id")
+        relation = edge.get("relation") or "dependency"
+        row: dict[str, Any] = {
+            "link_id": _node_link_id("edge", f"{source_id}-{relation}-{target_id}"),
+            "source_node_id": source_id,
+            "target_node_id": target_id,
+            "source_link_id": _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
+            "target_link_id": _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
+            "relation": relation,
+            "state": edge.get("status") or "visible",
+        }
+        for key in ("direction", "source", "source_graph", "edge_source", "relation_source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
+            _set_if_present(row, key, edge.get(key))
+        edge_rows.append(row)
+
+    warning_rows = [_warning_link_fields(warning, rpg_by_id, code_by_id) for warning in warnings if isinstance(warning, dict)]
+    focused_graph = _focused_graph_metadata(
+        semantic_nodes,
+        code_nodes,
+        mapping_rows,
+        edge_rows,
+        hidden_counts,
+        warning_rows,
+        graph_context,
+    )
+    return {
+        "summary": {
+            "semantic_nodes": len(semantic_nodes),
+            "code_nodes": len(code_nodes),
+            "mappings": len(mapping_rows),
+            "edges": len(edge_rows),
+            "warnings": len(warning_rows),
+            "changed_files": len(changed_files),
+        },
+        "semantic_nodes": semantic_nodes,
+        "code_nodes": code_nodes,
+        "mappings": mapping_rows,
+        "edges": edge_rows,
+        "hidden_counts": hidden_counts,
+        "warnings": warning_rows,
+        "changed_files": _changed_file_refs(changed_files, diff_anchors),
+        "hierarchy": focused_graph["hierarchy"],
+        "default_focus": focused_graph["default_focus"],
+        "focused_graph": focused_graph,
+        "graph_context": graph_context,
+    }
+
+
 def _rpg_node_row(node_id: str, node: dict[str, Any], paths: dict[str, str], changed_files: list[str]) -> dict[str, Any]:
     meta = node.get("meta") if isinstance(node.get("meta"), dict) else {}
+    name = node.get("name") or node_id
     return {
         "node_id": node_id,
-        "name": node.get("name") or node_id,
+        "link_id": _node_link_id("rpg", node_id),
+        "name": name,
+        "symbol": name,
         "type": node.get("node_type") or node.get("type") or meta.get("type_name"),
         "node_type": node.get("node_type") or node.get("type") or meta.get("type_name"),
         "path": meta.get("path") or node.get("path"),
@@ -359,19 +1000,24 @@ def _rpg_node_row(node_id: str, node: dict[str, Any], paths: dict[str, str], cha
         "change": "semantic",
         "changed_files": changed_files,
         "mapping_status": "mapped",
+        "state": "mapped",
     }
 
 
 def _dep_node_row(dep_id: str, attrs: dict[str, Any], changed_files: list[str], mapped_rpg_ids: list[str]) -> dict[str, Any]:
+    symbol = attrs.get("name") or dep_id.rsplit(":", 1)[-1]
     row: dict[str, Any] = {
         "node_id": dep_id,
         "dep_node_id": dep_id,
+        "link_id": _node_link_id("code", dep_id),
         "path": _dep_node_path(dep_id, attrs),
-        "symbol": attrs.get("name") or dep_id.rsplit(":", 1)[-1],
+        "name": symbol,
+        "symbol": symbol,
         "type": attrs.get("type") or attrs.get("kind"),
         "change": "code",
         "changed_files": changed_files,
         "source": "dep_graph",
+        "state": "mapped" if mapped_rpg_ids else "missing_mapping",
     }
     if attrs.get("signature") not in (None, ""):
         row["signature"] = attrs.get("signature")
@@ -409,6 +1055,7 @@ def _edge_rows(dep_edges: Any, code_ids: set[str]) -> list[dict[str, Any]]:
 
 def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semantic_total: int) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]]]:
     changed_files = _changed_report_files(result, code_deltas)
+    diff_anchors = _diff_anchor_map(code_deltas)
     rpg_data = _load_report_rpg(result)
     dep_graph = rpg_data.get("dep_graph") if isinstance(rpg_data.get("dep_graph"), dict) else {}
     dep_to_rpg = rpg_data.get("_dep_to_rpg_map") if isinstance(rpg_data.get("_dep_to_rpg_map"), dict) else {}
@@ -466,47 +1113,61 @@ def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semanti
     for node in code_nodes:
         unmatched_files.difference_update(str(path) for path in _listify(node.get("changed_files")))
     unmatched_code_deltas = [row for row in code_deltas if (row.get("file") or row.get("path")) in unmatched_files]
-    summary = {
-        "selected_feature_groups": len(semantic_nodes),
-        "primary_rpg_nodes": len(semantic_nodes),
-        "primary_code_nodes": len(code_nodes),
-        "mapped_code_relations": len(mappings),
-        "missing_mappings": len([node for node in code_nodes if not node.get("mapped_rpg_node_ids")]),
-        "edges": len(dep_edges),
-        "warnings": len(warnings),
+    hidden_counts: dict[str, Any] = {}
+    graph_context = {
+        "rpg_nodes": result.get("node_count", result.get("rpg_nodes")),
+        "rpg_edges": result.get("edge_count", result.get("rpg_edges")),
+        "rpg_nodes_delta": result.get("nodes_delta"),
+        "rpg_edges_delta": result.get("edges_delta"),
+        "dep_nodes": result.get("dep_nodes"),
+        "dep_edges": result.get("dep_edges"),
+        "dep_nodes_delta": result.get("dep_nodes_delta"),
+        "dep_edges_delta": result.get("dep_edges_delta"),
+        "dep_to_rpg_map_size": result.get("dep_to_rpg_map_size"),
         "changed_files": len(changed_files),
         "semantic_delta": semantic_total,
     }
-    nodes_view = {
-        "summary": {
-            "semantic_nodes": len(semantic_nodes),
-            "code_nodes": len(code_nodes),
-            "mappings": len(mappings),
-            "edges": len(dep_edges),
-            "warnings": len(warnings),
-            "changed_files": len(changed_files),
-        },
-        "semantic_nodes": semantic_nodes,
-        "code_nodes": code_nodes,
-        "mappings": mappings,
-        "edges": dep_edges,
-        "warnings": warnings,
-        "changed_files": [{"path": file_path} for file_path in changed_files],
-        "hidden_counts": {},
+    graph_context = {key: value for key, value in graph_context.items() if value not in (None, "")}
+    nodes_view = _build_nodes_view(
+        semantic_nodes,
+        code_nodes,
+        mappings,
+        dep_edges,
+        hidden_counts,
+        warnings,
+        changed_files,
+        diff_anchors,
+        graph_context,
+    )
+    enriched_semantic_nodes = nodes_view["semantic_nodes"]
+    enriched_code_nodes = nodes_view["code_nodes"]
+    enriched_mappings = nodes_view["mappings"]
+    enriched_edges = nodes_view["edges"]
+    enriched_warnings = nodes_view["warnings"]
+    summary = {
+        "selected_feature_groups": len(enriched_semantic_nodes),
+        "primary_rpg_nodes": len(enriched_semantic_nodes),
+        "primary_code_nodes": len(enriched_code_nodes),
+        "mapped_code_relations": len(enriched_mappings),
+        "missing_mappings": len([node for node in enriched_code_nodes if not node.get("mapped_rpg_node_ids")]),
+        "edges": len(enriched_edges),
+        "warnings": len(enriched_warnings),
+        "changed_files": len(changed_files),
+        "semantic_delta": semantic_total,
     }
     focused_view = {
         "summary": summary,
         "nodes_view": nodes_view,
-        "primary_rpg_nodes": semantic_nodes,
-        "primary_code_nodes": code_nodes,
-        "mappings": mappings,
-        "edges": dep_edges,
-        "hidden_counts": {},
-        "warnings": warnings,
-        "changed_files": changed_files,
+        "primary_rpg_nodes": enriched_semantic_nodes,
+        "primary_code_nodes": enriched_code_nodes,
+        "mappings": enriched_mappings,
+        "edges": enriched_edges,
+        "hidden_counts": hidden_counts,
+        "warnings": enriched_warnings,
+        "changed_files": nodes_view["changed_files"],
         "unmatched_code_deltas": unmatched_code_deltas,
     }
-    return focused_view, semantic_nodes, code_nodes
+    return focused_view, enriched_semantic_nodes, enriched_code_nodes
 
 
 def _hook_context(result: dict) -> dict[str, Any]:
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 44731be..71be4a7 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -539,8 +539,49 @@ def fake_write_command_report(run):
     assert nodes_view["summary"]["semantic_nodes"] == 1
     assert nodes_view["summary"]["code_nodes"] == 3
     assert nodes_view["summary"]["mappings"] == 2
-    assert nodes_view["semantic_nodes"][0]["node_id"] == "feature_a"
-    assert nodes_view["code_nodes"][1]["line_range"] == {"start": 10, "end": 12}
+    assert nodes_view["summary"]["edges"] == 1
+    assert nodes_view["summary"]["changed_files"] == 2
+    semantic_node = nodes_view["semantic_nodes"][0]
+    code_nodes = {row["node_id"]: row for row in nodes_view["code_nodes"]}
+    mappings = {(row["rpg_node_id"], row["code_node_id"]): row for row in nodes_view["mappings"]}
+    edge = nodes_view["edges"][0]
+    assert semantic_node["node_id"] == "feature_a"
+    assert semantic_node["link_id"] == "rpg-feature_a"
+    assert semantic_node["mapped_code_node_ids"] == ["scripts/a.py", "scripts/a.py:f"]
+    assert semantic_node["mapped_code_link_ids"] == ["code-scripts-a.py", "code-scripts-a.py-f"]
+    assert semantic_node["mapped_code"][1]["line_range"] == {"start": 10, "end": 12}
+    assert semantic_node["changed_files"] == [{"path": "scripts/a.py", "diff_anchor": "diff-scripts_a.py"}]
+    assert code_nodes["scripts/a.py:f"]["line_range"] == {"start": 10, "end": 12}
+    assert code_nodes["scripts/a.py:f"]["link_id"] == "code-scripts-a.py-f"
+    assert code_nodes["scripts/a.py:f"]["diff_anchor"] == "diff-scripts_a.py"
+    assert code_nodes["scripts/a.py:f"]["mapped_rpg_node_ids"] == ["feature_a"]
+    assert code_nodes["scripts/a.py:f"]["mapped_rpg_link_ids"] == ["rpg-feature_a"]
+    assert code_nodes["scripts/a.py:f"]["mapped_rpg"][0]["feature_path"] == "test_repo / Refresh graph visualization"
+    assert code_nodes["tests/test_a.py"]["link_id"] == "code-tests-test_a.py"
+    assert "mapped_rpg" not in code_nodes["tests/test_a.py"]
+    assert mappings[("feature_a", "scripts/a.py")]["link_id"] == "map-feature_a-scripts-a.py"
+    assert mappings[("feature_a", "scripts/a.py:f")]["source_link_id"] == "rpg-feature_a"
+    assert mappings[("feature_a", "scripts/a.py:f")]["target_link_id"] == "code-scripts-a.py-f"
+    assert mappings[("feature_a", "scripts/a.py:f")]["changed_files"] == [{"path": "scripts/a.py", "diff_anchor": "diff-scripts_a.py"}]
+    assert edge["link_id"] == "edge-scripts-a.py-f-imports-tests-test_a.py"
+    assert edge["source_link_id"] == "code-scripts-a.py-f"
+    assert edge["target_link_id"] == "code-tests-test_a.py"
+    assert nodes_view["changed_files"] == [
+        {"path": "scripts/a.py", "diff_anchor": "diff-scripts_a.py"},
+        {"path": "tests/test_a.py", "diff_anchor": "diff-tests_test_a.py"},
+    ]
+    assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
+    assert nodes_view["hierarchy"]["children"][0]["id"] == "feature-path-test_repo"
+    assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
+    assert nodes_view["focused_graph"]["hierarchy"] == nodes_view["hierarchy"]
+    assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]
+    assert nodes_view["graph_context"]["rpg_nodes"] == 4504
+    assert nodes_view["graph_context"]["dep_edges"] == 5498
+    assert nodes_view["graph_context"]["semantic_delta"] == 3
+    assert "rpg-feature_a" in nodes_view["default_focus"]["node_link_ids"]
+    assert "code-scripts-a.py-f" in nodes_view["default_focus"]["focused_code_link_ids"]
+    assert "edge-scripts-a.py-f-imports-tests-test_a.py" in nodes_view["default_focus"]["edge_link_ids"]
+    assert "code-tests-test_a.py" in nodes_view["default_focus"]["relation_endpoint_link_ids"]
     assert evidence["code_deltas"][1]["file"] == "tests/test_a.py"
     assert evidence["semantic_summary"] == {"added": 0, "deleted": 0, "modified": 3, "renamed": 0}
     assert evidence["commit_range"] == {
@@ -601,9 +642,31 @@ def fake_write_command_report(run):
     assert captured["verification"][2]["detail"] == "RPG semantic delta 为 0"
     assert focused["summary"]["primary_rpg_nodes"] == 0
     assert focused["summary"]["primary_code_nodes"] == 0
+    assert nodes_view["summary"]["semantic_nodes"] == 0
+    assert nodes_view["summary"]["code_nodes"] == 0
+    assert nodes_view["summary"]["warnings"] == 2
     assert nodes_view["semantic_nodes"] == []
     assert nodes_view["code_nodes"] == []
     assert nodes_view["mappings"] == []
+    assert nodes_view["edges"] == []
+    assert nodes_view["changed_files"] == [{"path": "docs/readme.md", "diff_anchor": "diff-docs_readme.md"}]
+    assert nodes_view["hierarchy"] == {
+        "id": "focused-graph-root",
+        "name": "Focused graph",
+        "kind": "root",
+        "feature_name": "Focused graph",
+        "feature_path": "Focused graph",
+        "meta": {"hidden_counts": {}, "warnings": 2, "edges": 0},
+        "children": [],
+    }
+    assert nodes_view["default_focus"]["node_link_ids"] == []
+    assert nodes_view["default_focus"]["semantic_node_ids"] == []
+    assert nodes_view["default_focus"]["code_node_ids"] == []
+    assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
+    assert nodes_view["focused_graph"]["warning_count"] == 2
+    assert nodes_view["graph_context"]["semantic_delta"] == 0
+    assert nodes_view["graph_context"]["changed_files"] == 1
+    assert focused["changed_files"] == [{"path": "docs/readme.md", "diff_anchor": "diff-docs_readme.md"}]
     assert captured.get("rpg_deltas", []) == []
     assert captured.get("dep_graph_deltas", []) == []
     assert any(warning["message"] == "RPG semantic delta 为 0" for warning in focused["warnings"])

From 79dfe3662ff298df458129819958c99667f9d267 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Wed, 8 Jul 2026 11:33:12 +0000
Subject: [PATCH 42/56] rpg_edit: Update _feature_evidence_groups() at lines
 1466-1807 and _bu

---
 CoderMind/scripts/common/run_report.py      | 60 ++++++++++++++-------
 CoderMind/scripts/rpg_edit/review.py        | 47 +++++++++++++---
 CoderMind/tests/test_rpg_edit_run_report.py | 42 ++++++++++++---
 CoderMind/tests/test_run_report.py          | 23 +++++++-
 4 files changed, 138 insertions(+), 34 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 29b496c..46b1140 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -337,7 +337,7 @@ def _render_page(
 <style>
 :root {{ color-scheme: light; --bg:#f6f8fb; --card:#fff; --text:#1f2937; --muted:#6b7280; --line:#d9e0ea; --accent:#2563eb; }}
 body {{ margin:0; font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif; background:var(--bg); color:var(--text); }}
-main {{ max-width:1120px; margin:0 auto; padding:32px 20px 48px; }}
+main {{ max-width:1440px; margin:0 auto; padding:32px 20px 48px; }}
 header {{ margin-bottom:24px; }}
 h1 {{ margin:0 0 8px; font-size:30px; }}
 .meta {{ color:var(--muted); font-size:14px; display:flex; flex-wrap:wrap; gap:12px; }}
@@ -384,8 +384,8 @@ def _render_page(
 .focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb; padding:6px 10px; font:inherit; }}
 .focused-graph-toolbar input::placeholder {{ color:#94a3b8; }}
 .focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:#cbd5e1; }}
-.focused-graph-stage {{ border:1px solid #334155; border-radius:12px; background:#0f172a; min-height:520px; position:relative; overflow:hidden; }}
-.focused-graph-svg {{ display:block; width:100%; height:520px; cursor:grab; touch-action:none; }}
+.focused-graph-stage {{ border:1px solid #334155; border-radius:12px; background:#0f172a; min-height:680px; position:relative; overflow:hidden; }}
+.focused-graph-svg {{ display:block; width:100%; height:680px; cursor:grab; touch-action:none; }}
 .focused-graph-svg:active {{ cursor:grabbing; }}
 .focused-graph-detail {{ position:absolute; top:14px; right:14px; z-index:2; width:min(320px,calc(100% - 28px)); max-height:calc(100% - 28px); overflow:auto; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.94); color:#e5e7eb; padding:12px; box-shadow:0 18px 40px rgba(2,6,23,.35); }}
 .focused-graph-detail h3 {{ margin:0 0 8px; font-size:15px; color:#f8fafc; overflow-wrap:anywhere; }}
@@ -1097,7 +1097,7 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
                     "name": node.get("name") or node.get("symbol") or node.get("node_id") or "feature",
                     "kind": "feature",
                     "feature_name": node.get("name") or node.get("symbol") or node.get("node_id") or "feature",
-                    "feature_path": node.get("feature_path") or node.get("breadcrumb_path") or node.get("path"),
+                    "feature_path": node.get("breadcrumb_path") or node.get("feature_path"),
                     "mapped_code": node.get("mapped_code"),
                     "mapped_code_node_ids": node.get("mapped_code_node_ids"),
                     "mapped_code_link_ids": node.get("mapped_code_link_ids"),
@@ -1352,7 +1352,7 @@ def _focused_graph_runtime() -> str:
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
   const width = Number(svg.getAttribute('width')) || 960;
-  const height = Number(svg.getAttribute('height')) || 520;
+  const height = Number(svg.getAttribute('height')) || 680;
   const defaultFocus = data.default_focus || {};
   const defaultShowEdges = defaultFocus.show_edges !== false;
   const text = value => value === undefined || value === null ? '' : String(value);
@@ -1525,24 +1525,40 @@ def _focused_graph_runtime() -> str:
     return '';
   }
 
-  function mappedCodeHtml(value, detail) {
+  function canonicalMappedCodeRefs(value, detail) {
     let refs = detailItems(value);
     if (!refs.length) {
       const paths = list(detail.mapped_code_paths);
       const symbols = list(detail.mapped_code_symbols);
-      if (paths.length || symbols.length || detail.mapped_code_path || detail.mapped_code_symbol) {
-        refs = [{path: detail.mapped_code_path || paths[0], symbol: detail.mapped_code_symbol || symbols[0]}];
-      }
+      const count = Math.max(paths.length, symbols.length, detail.mapped_code_path ? 1 : 0, detail.mapped_code_symbol ? 1 : 0);
+      refs = Array.from({length: count}, (_, index) => ({
+        path: index === 0 ? (detail.mapped_code_path || paths[index]) : paths[index],
+        symbol: index === 0 ? (detail.mapped_code_symbol || symbols[index]) : symbols[index],
+      }));
     }
-    return detailListHtml(refs, item => {
-      if (item && typeof item === 'object') {
-        const label = uniqueTexts([item.path, item.symbol, item.node_id || item.link_id]).join(' · ');
-        const meta = uniqueTexts([item.type || item.kind, lineRangeText(item.line_range), item.source]).join(' · ');
-        if (!label && !meta) return '';
-        return `${escapeHtml(label || meta)}${label && meta ? `<span>${escapeHtml(meta)}</span>` : ''}`;
-      }
-      return escapeHtml(item);
+    const seenRefs = new Set();
+    const canonical = [];
+    refs.forEach(item => {
+      const ref = item && typeof item === 'object'
+        ? {
+            path: text(item.path || item.file || item.module),
+            symbol: text(item.symbol || item.name),
+            node_id: text(item.node_id || item.dep_node_id || item.link_id),
+            type: text(item.type || item.kind),
+            line_range: lineRangeText(item.line_range),
+          }
+        : {path: '', symbol: '', node_id: text(item), type: '', line_range: ''};
+      const label = uniqueTexts([ref.path, ref.symbol]).join(' · ') || ref.node_id;
+      const key = uniqueTexts([ref.path, ref.symbol]).join('::') || ref.node_id || label;
+      if (!label || seenRefs.has(key)) return;
+      seenRefs.add(key);
+      canonical.push({label, meta: uniqueTexts([ref.type, ref.line_range]).join(' · ')});
     });
+    return canonical;
+  }
+
+  function mappedCodeHtml(value, detail) {
+    return detailListHtml(canonicalMappedCodeRefs(value, detail), ref => `${escapeHtml(ref.label)}${ref.meta ? `<span>${escapeHtml(ref.meta)}</span>` : ''}`);
   }
 
   function addValueRow(rows, label, value) {
@@ -1555,6 +1571,12 @@ def _focused_graph_runtime() -> str:
     rows.push(`<div class="focused-graph-detail-row"><dt>${escapeHtml(label)}</dt><dd>${value}</dd></div>`);
   }
 
+  function isCodeContextDetail(detail) {
+    return uniqueTexts([detail.kind, detail.type, detail.node_type])
+      .map(item => item.toLowerCase())
+      .some(item => ['code', 'context', 'code_group', 'context_group'].includes(item));
+  }
+
   function renderFocusedGraphDetail(d) {
     if (!detailEl) return;
     if (!d) {
@@ -1567,7 +1589,7 @@ def _focused_graph_runtime() -> str:
     const relationText = uniqueTexts([detail.relation, detail.direction]).join(' · ');
     const sourceText = uniqueTexts([detail.source, detail.source_graph, detail.edge_source, detail.relation_source]).join(' · ');
     addValueRow(rows, 'Node id', detail.node_id || detail.dep_node_id || detail.id);
-    addValueRow(rows, 'Feature path', detail.feature_path || detail.breadcrumb_path || detail.breadcrumb);
+    if (!isCodeContextDetail(detail)) addValueRow(rows, 'Feature path', detail.breadcrumb_path || detail.feature_path);
     addValueRow(rows, 'Path', detail.path || detail.module || detail.file);
     addValueRow(rows, 'Symbol', detail.symbol);
     addValueRow(rows, 'Type', typeText);
@@ -1839,7 +1861,7 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         f"{summary_html}{controls}{legend}"
         f"<script type=\"application/json\" data-focused-graph-json>{graph_json}</script>"
         '<div class="focused-graph-stage">'
-        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="520"></svg>'
+        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="680"></svg>'
         '<aside class="focused-graph-detail" data-focused-graph-detail aria-live="polite"><h3>Node details</h3><p class="empty">Select a node to inspect metadata.</p></aside>'
         f'<div class="focused-graph-fallback" data-focused-graph-fallback{fallback_hidden}>Static focused graph fallback is available when D3 cannot run.{d3_missing_note}</div>'
         '</div>'
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 5160a33..aefd46f 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -28,7 +28,7 @@
 import uuid
 from pathlib import Path
 from string import Template
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 # This file lives in ``scripts/rpg_edit/``; go up two levels to land
 # on ``scripts/`` so ``common.*``, ``rpg.*`` etc. import cleanly.
@@ -474,7 +474,7 @@ def _add_hierarchy_path(root: Dict[str, Any], parts: List[str], leaf: Dict[str,
 
 
 def _semantic_hierarchy_parts(node: Dict[str, Any]) -> List[str]:
-    for key in ("breadcrumb", "breadcrumb_path", "feature_path", "path"):
+    for key in ("breadcrumb_path", "feature_path"):
         parts = _hierarchy_segments(node.get(key))
         if parts:
             return parts[:-1] if len(parts) > 1 else []
@@ -597,7 +597,7 @@ def merge_code_metadata(row: Dict[str, Any], refs: List[Dict[str, Any]]) -> None
         row["mapped_code_count"] = len(merged)
 
     def feature_path_text(node: Dict[str, Any], group_parts: List[str], feature_name: str) -> str:
-        for key in ("feature_path", "breadcrumb_path", "breadcrumb", "path"):
+        for key in ("breadcrumb_path", "feature_path"):
             value = node.get(key)
             parts = _hierarchy_segments(value)
             if parts:
@@ -782,6 +782,18 @@ def _focused_graph_default_focus(
     warnings: List[Dict[str, Any]],
 ) -> Dict[str, Any]:
     semantic_links = [str(node.get("link_id") or _node_link_id("rpg", node.get("node_id"))) for node in semantic_nodes]
+    focused_semantic_links = [
+        str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        for node in semantic_nodes
+        if node.get("selected")
+        or node.get("changed")
+        or node.get("changed_files")
+        or node.get("diff_anchor")
+        or node.get("warning_types")
+        or node.get("mapping_status")
+        or node.get("locate_status")
+        or node.get("apply_action")
+    ]
     code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
     semantic_link_set = set(semantic_links)
     code_to_feature_links: Dict[str, List[str]] = {}
@@ -914,9 +926,9 @@ def owner_feature_links(edge: Dict[str, Any]) -> List[str]:
     warning_links = []
     for warning in warnings:
         warning_links.extend(_listify(warning.get("node_link_id")) + _listify(warning.get("code_link_id")))
-    node_link_ids = _ordered_unique(semantic_links + changed_feature_links + changed_code_links + warning_links)
+    node_link_ids = _ordered_unique(focused_semantic_links + changed_feature_links + changed_code_links + warning_links)
     if not node_link_ids:
-        node_link_ids = _ordered_unique(semantic_links + code_links)
+        node_link_ids = _ordered_unique(focused_semantic_links or semantic_links + code_links)
 
     expanded_node_ids: List[Any] = ["focused-graph-root"]
     focused_path_node_ids: List[Any] = []
@@ -1006,8 +1018,22 @@ def _build_nodes_view(
     diff_anchors: Dict[str, str],
     *,
     graph_context: Optional[Dict[str, Any]] = None,
+    current_rpg_nodes: Optional[Mapping[str, Dict[str, Any]]] = None,
 ) -> Dict[str, Any]:
-    rpg_by_id = {str(row.get("node_id")): row for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
+    selected_rpg_ids = {str(row.get("node_id")) for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
+    all_rpg_by_id: Dict[str, Dict[str, Any]] = {}
+    for node_id, node in (current_rpg_nodes or {}).items():
+        node_id_text = str(node_id)
+        row = dict(node)
+        row["node_id"] = node_id_text
+        row.setdefault("link_id", _node_link_id("rpg", node_id_text))
+        all_rpg_by_id[node_id_text] = row
+    for node in primary_rpg_nodes:
+        node_id = str(node.get("node_id") or "")
+        if not node_id:
+            continue
+        all_rpg_by_id[node_id] = {**all_rpg_by_id.get(node_id, {}), **node, "node_id": node_id}
+    rpg_by_id = all_rpg_by_id or {str(row.get("node_id")): row for row in primary_rpg_nodes if row.get("node_id") not in (None, "")}
     code_by_id = {str(row.get("node_id") or row.get("dep_node_id")): row for row in primary_code_nodes if (row.get("node_id") or row.get("dep_node_id")) not in (None, "")}
     code_ids_by_rpg: Dict[str, List[str]] = {}
     warnings_by_rpg: Dict[str, List[Dict[str, Any]]] = {}
@@ -1028,14 +1054,18 @@ def _build_nodes_view(
             warnings_by_code.setdefault(str(code_id), []).append(warning)
 
     semantic_nodes: List[Dict[str, Any]] = []
-    for node in primary_rpg_nodes:
+    semantic_source_nodes = list(all_rpg_by_id.values()) if all_rpg_by_id else primary_rpg_nodes
+    for node in semantic_source_nodes:
         node_id = str(node.get("node_id") or "")
+        is_selected = node_id in selected_rpg_ids
         row: Dict[str, Any] = {
             "node_id": node_id,
             "link_id": node.get("link_id") or _node_link_id("rpg", node_id),
-            "state": _node_state(node),
+            "state": _node_state(node) if is_selected else _node_state(node, "context"),
             "mapping_status": node.get("mapping_status") or node.get("status"),
         }
+        if is_selected:
+            row["selected"] = True
         for key in ("name", "symbol", "type", "node_type", "path", "feature_path", "breadcrumb", "breadcrumb_path", "locate_status", "score", "reason", "apply_action"):
             _set_if_present(row, key, node.get(key))
         changed_refs = _changed_file_refs(_listify(node.get("changed_files")) or _listify(node.get("affected_files")), diff_anchors)
@@ -1765,6 +1795,7 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         changed_files,
         diff_anchors,
         graph_context=graph_context,
+        current_rpg_nodes=current_rpg_nodes,
     )
     summary = {
         "selected_feature_groups": len(primary_rpg_nodes_all),
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 9c842d3..3b1e4a8 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -192,7 +192,8 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
                 "node_type": "feature",
                 "meta": {"path": "a.py"},
                 "children": [
-                    {"id": "n2", "name": "Missing Node", "node_type": "feature", "meta": {"path": "b.py"}, "children": []}
+                    {"id": "n2", "name": "Missing Node", "node_type": "feature", "meta": {"path": "b.py"}, "children": []},
+                    {"id": "n3", "name": "Context Node", "node_type": "feature", "meta": {"path": "context.py"}, "children": []},
                 ],
             },
             "edges": [],
@@ -328,14 +329,21 @@ def fake_write_command_report(run):
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in focused["warnings"])
         nodes_view = focused["nodes_view"]
         assert nodes_view["summary"]["selected_feature_groups"] == 2
+        assert nodes_view["summary"]["semantic_nodes"] == 3
         semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
         assert semantic_by_id["n1"]["breadcrumb_path"] == "Node"
         assert semantic_by_id["n1"]["mapping_status"] == "mapped"
+        assert semantic_by_id["n1"]["selected"] is True
         assert semantic_by_id["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
         assert semantic_by_id["n1"]["hidden_counts"]["callers"] == 1
         assert semantic_by_id["n2"]["breadcrumb_path"] == "Node / Missing Node"
         assert semantic_by_id["n2"]["state"] == "missing_mapping"
         assert semantic_by_id["n2"]["mapping_status"] == "missing"
+        assert semantic_by_id["n2"]["selected"] is True
+        assert semantic_by_id["n3"]["breadcrumb_path"] == "Node / Context Node"
+        assert semantic_by_id["n3"]["path"] == "context.py"
+        assert semantic_by_id["n3"]["state"] == "context"
+        assert "selected" not in semantic_by_id["n3"]
         code = nodes_view["code_nodes"][0]
         assert code["dep_node_id"] == "a.py:f"
         assert code["path"] == "a.py"
@@ -350,8 +358,13 @@ def fake_write_command_report(run):
         assert nodes_view["hidden_counts"]["callers"] == 1
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
+        hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
+        assert "rpg-n3" in hierarchy_text
+        assert "Node / Context Node" in hierarchy_text
+        assert '"feature_path": "context.py"' not in hierarchy_text
         assert nodes_view["default_focus"]["node_link_ids"]
         assert "rpg-n1" in nodes_view["default_focus"]["node_link_ids"]
+        assert "rpg-n3" not in nodes_view["default_focus"]["node_link_ids"]
         assert nodes_view["default_focus"]["edge_depth"] == 1
         assert nodes_view["default_focus"]["show_edges"] is True
         assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
@@ -359,7 +372,7 @@ def fake_write_command_report(run):
         assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]
         assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
         assert nodes_view["graph_context"]["current_graph_available"] is True
-        assert nodes_view["graph_context"]["current_rpg_nodes"] == 2
+        assert nodes_view["graph_context"]["current_rpg_nodes"] == 3
         assert nodes_view["graph_context"]["current_dep_nodes"] == 1
         assert "+new <unsafe>" not in json.dumps(nodes_view, ensure_ascii=False)
         return report_path
@@ -445,7 +458,15 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     rpg_path.write_text(
         json.dumps({
             "repo_name": "test",
-            "root": {"id": "planned", "name": "Planned Node", "node_type": "feature", "meta": {"path": "scripts/common/run_report.py"}, "children": []},
+            "root": {
+                "id": "planned",
+                "name": "Planned Node",
+                "node_type": "feature",
+                "meta": {"path": "scripts/common/run_report.py"},
+                "children": [
+                    {"id": "background", "name": "Background Node", "node_type": "feature", "meta": {"path": "background.py"}, "children": []}
+                ],
+            },
             "edges": [],
             "dep_graph": {
                 "nodes": {dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "line_start": 537, "line_end": 564, "rpg_nodes": ["planned"]}},
@@ -558,12 +579,16 @@ def fake_write_command_report(run):
         assert "impact" in mapping["source"]
         nodes_view = focused["nodes_view"]
         assert nodes_view["summary"]["selected_feature_groups"] == 1
-        semantic = nodes_view["semantic_nodes"][0]
-        assert semantic["node_id"] == "planned"
+        assert nodes_view["summary"]["semantic_nodes"] == 2
+        semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
+        semantic = semantic_by_id["planned"]
         assert semantic["breadcrumb_path"] == "Planned Node"
         assert semantic["locate_status"] == "missing"
         assert semantic["mapping_status"] == "mapped"
+        assert semantic["selected"] is True
         assert semantic["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
+        assert semantic_by_id["background"]["breadcrumb_path"] == "Planned Node / Background Node"
+        assert semantic_by_id["background"]["state"] == "context"
         code = nodes_view["code_nodes"][0]
         assert code["dep_node_id"] == dep_id
         assert code["path"] == "scripts/common/run_report.py"
@@ -575,13 +600,18 @@ def fake_write_command_report(run):
         assert bridge["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
         assert any(row["type"] == "missing_reason" and row["node_id"] == "planned" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
+        hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
+        assert "rpg-background" in hierarchy_text
+        assert '"feature_path": "Planned Node"' in hierarchy_text
+        assert '"feature_path": "scripts/common/run_report.py"' not in hierarchy_text
         assert nodes_view["default_focus"]["node_link_ids"] == ["rpg-planned", "code-scripts-common-run_report.py-_render_artifacts"]
+        assert "rpg-background" not in nodes_view["default_focus"]["node_link_ids"]
         assert nodes_view["default_focus"]["edge_depth"] == 1
         assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
         assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]
         assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
         assert nodes_view["graph_context"]["current_graph_available"] is True
-        assert nodes_view["graph_context"]["current_rpg_nodes"] == 1
+        assert nodes_view["graph_context"]["current_rpg_nodes"] == 2
         assert nodes_view["graph_context"]["current_dep_nodes"] == 1
         assert focused["apply"]["status"] == "dep_refreshed"
         return report_path
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 6c8fb53..c3ffb86 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -156,6 +156,10 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
                             "state": "mapped",
                             "mapping_status": "mapped",
                             "reason": "selected <reason>",
+                            "mapped_code": [
+                                {"node_id": "a.py:f<script>", "link_id": "code-a.py-f-script", "path": "a.py<script>", "symbol": "func <unsafe>", "type": "function<script>", "line_range": {"start": 10, "end": 12}},
+                                {"node_id": "duplicate-node-id", "link_id": "duplicate-link-id", "path": "a.py<script>", "symbol": "func <unsafe>", "source": "duplicate-source"},
+                            ],
                             "mapped_code_node_ids": ["a.py:f<script>"],
                             "changed_files": [{"path": "a.py", "diff_anchor": "diff-a.py"}],
                             "hidden_counts": {"callers": 3},
@@ -177,6 +181,8 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
                             "link_id": "code-a.py-f-script",
                             "symbol": "func <unsafe>",
                             "path": "a.py",
+                            "feature_path": "SHOULD NOT RENDER FROM CODE",
+                            "breadcrumb_path": "SHOULD NOT RENDER FROM CODE BREADCRUMB",
                             "type": "function<script>",
                             "line_range": {"start": 10, "end": 12},
                             "state": "mapped",
@@ -249,6 +255,7 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
                         "kind": "root",
                         "children": [
                             {"id": "rpg-n1-script", "name": "Node <unsafe>", "kind": "semantic"},
+                            {"id": "rpg-background", "name": "Background feature", "kind": "feature", "feature_path": "Root / Background feature"},
                             {"id": "code-a.py-f-script", "name": "func <unsafe>", "kind": "code"},
                         ],
                     },
@@ -361,6 +368,8 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
 
     html = report.read_text(encoding="utf-8")
     assert "Focused graph" in html
+    assert "main { max-width:1440px;" in html
+    assert "height=\"680\"" in html
     assert "Focused nodes map" not in html
     assert "semantic-code impact chain" not in html
     assert html.count("<h2>Focused graph</h2>") == 1
@@ -397,7 +406,8 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
-    assert ".focused-graph-stage { border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
+    assert ".focused-graph-stage { border:1px solid #334155; border-radius:12px; background:#0f172a; min-height:680px;" in html
+    assert ".focused-graph-svg { display:block; width:100%; height:680px;" in html
     assert ".focused-graph-toolbar { display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
     assert ".focused-graph-toolbar button, .focused-graph-toolbar input { border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb;" in html
     assert ".focused-graph-legend { display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
@@ -419,6 +429,10 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "return text(detail.feature_name || detail.name || detail.node_id || detail.dep_node_id || detail.id || d.id || 'node');" in html
     assert "function mappedCodeLabel" not in html
     assert "return mapped && !base.includes(mapped)" not in html
+    assert "function canonicalMappedCodeRefs" in html
+    assert "if (!isCodeContextDetail(detail)) addValueRow(rows, 'Feature path', detail.breadcrumb_path || detail.feature_path);" in html
+    assert "item.source" not in html
+    assert "SHOULD NOT RENDER FROM CODE" in html
     assert "expandDepth" in html
     assert "collapseDepth" in html
     assert "Expand hierarchy depth" in html
@@ -474,11 +488,18 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert graph_payload["summary"]["edges"] == 3
     assert graph_payload["summary"]["relation_edges"] == 3
     assert graph_payload["summary"]["context_edges"] == 3
+    assert any(node.get("id") == "rpg-background" for node in graph_payload["hierarchy"]["children"])
     relation_links = [link for link in graph_payload["links"] if link.get("relation") != "contains"]
     assert len(relation_links) == 3
     nodes_by_id = {node["id"]: node for node in graph_payload["nodes"]}
     assert nodes_by_id["rpg-n1-script"]["symbol"] == "NodeSymbol <unsafe>"
     assert nodes_by_id["rpg-n1-script"]["reason"] == "selected <reason>"
+    assert len(nodes_by_id["rpg-n1-script"]["mapped_code"]) == 2
+    canonical_refs = {
+        (ref.get("path"), ref.get("symbol"))
+        for ref in nodes_by_id["rpg-n1-script"]["mapped_code"]
+    }
+    assert canonical_refs == {("a.py<script>", "func <unsafe>")}
     assert nodes_by_id["rpg-n1-script"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
     assert nodes_by_id["rpg-n1-script"]["diff"] == {"path": "a.py", "href": "#diff-a.py"}
     assert nodes_by_id["code-a.py-f-script"]["symbol"] == "func <unsafe>"

From aaddfad425f4f2fde2b39696e3d7731f5debb971 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 02:01:34 +0000
Subject: [PATCH 43/56] rpg_edit: Update _review_summary_cards() at lines
 1841-1860 so the Sum

---
 CoderMind/scripts/common/run_report.py      | 17 +++++---
 CoderMind/scripts/rpg_edit/review.py        |  3 +-
 CoderMind/tests/test_rpg_edit_run_report.py |  4 ++
 CoderMind/tests/test_run_report.py          | 46 ++++++++++++++-------
 4 files changed, 46 insertions(+), 24 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 46b1140..227ba5f 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -328,6 +328,15 @@ def _render_page(
     status_html = f"<span class=\"status\">{_h(status)}</span>" if status else ""
     code_delta_anchors = _code_delta_anchors(code_deltas)
     code_file_anchors = _code_file_anchor_map(code_deltas, code_delta_anchors)
+    focused_graph_html = _render_focused_graph(focused_view, code_file_anchors)
+    code_deltas_html = _render_code_deltas(code_deltas, code_delta_anchors)
+    summary_html = _render_summary_cards(summary_cards)
+    timeline_html = _render_timeline(stages, verification)
+    safety_html = _render_safety_boundary(user_decisions)
+    if focused_graph_html:
+        primary_sections_html = summary_html + focused_graph_html + code_deltas_html + timeline_html + safety_html
+    else:
+        primary_sections_html = summary_html + timeline_html + safety_html + code_deltas_html
     return f"""<!doctype html>
 <html lang=\"en\">
 <head>
@@ -440,11 +449,7 @@ def _render_page(
 <h1>{_h(title)}</h1>
 <div class=\"meta\"><span>Command: <strong>{_h(command)}</strong></span><span>Generated: {_h(generated_at)}</span>{status_html}</div>
 </header>
-{_render_summary_cards(summary_cards)}
-{_render_timeline(stages, verification)}
-{_render_safety_boundary(user_decisions)}
-{_render_focused_graph(focused_view, code_file_anchors)}
-{_render_code_deltas(code_deltas, code_delta_anchors)}
+{primary_sections_html}
 {_render_artifacts(artifacts)}
 {_render_evidence(evidence)}
 </main>
@@ -1820,7 +1825,7 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     hidden_counts = nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else focused_view.get("hidden_counts", {})
     hidden_html = _hidden_context_html(hidden_counts if isinstance(hidden_counts, Mapping) else {})
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings") or focused_view.get("warnings")) if isinstance(warning, Mapping)]
-    warnings_html = f"<h3>Warnings</h3>{_chain_warning_html(warnings)}" if warnings else ""
+    warnings_html = f"<details><summary>Warnings</summary>{_chain_warning_html(warnings)}</details>" if warnings else ""
     relation_edge_total = len(_as_sequence(graph_payload.get("relation_edges") or graph_payload.get("edges") or graph_payload.get("links")))
     graph_json = _json_for_script(graph_payload)
     d3_js = _inline_d3()
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index aefd46f..4357512 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -1850,8 +1850,7 @@ def _review_summary_cards(
     result_value = "passed" if result.get("success", result.get("type") == "skipped") else "failed"
     changed_files = summary.get("changed_files", len(code_result.get("files_modified") or []))
     return [
-        {"label": "Review status", "value": result.get("type", "review")},
-        {"label": "Review result", "value": result_value},
+        {"label": "Review", "value": result.get("type", "review"), "detail": result_value},
         {"label": "Selected features", "value": summary.get("selected_feature_groups", len(plan.get("affected_nodes") or []))},
         {"label": "Mapped code relations", "value": summary.get("mapped_code_relations", 0)},
         {"label": "Missing mappings", "value": summary.get("missing_mappings", 0)},
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 3b1e4a8..e673fed 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -243,6 +243,10 @@ def fake_write_command_report(run):
         )
         assert review_artifact["status"] == "available"
         assert apply_artifact["status"] == "available"
+        summary_by_label = {row["label"]: row for row in data["summary"]}
+        assert summary_by_label["Review"] == {"label": "Review", "value": "skipped", "detail": "passed"}
+        assert "Review status" not in summary_by_label
+        assert "Review result" not in summary_by_label
         steps_by_name = {row["name"]: row for row in data["steps"]}
         assert steps_by_name["apply/dep-refresh"]["status"] == "success"
         assert "1 applied features" in steps_by_name["apply/dep-refresh"]["reason"]
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index c3ffb86..0ba8601 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -38,20 +38,32 @@ def test_common_run_report_run_report_exposes_current_impact_renderers_only() ->
 
 def test_common_run_report_write_command_report_escapes_content_and_writes_sections(tmp_path: Path) -> None:
     report = write_command_report(
-        CommandRun(
-            command="rpg/edit <script>alert(1)</script>",
-            title="Title <unsafe>",
-            status="ok <bad>",
-            summary=[
+        {
+            "command": "rpg/edit <script>alert(1)</script>",
+            "title": "Title <unsafe>",
+            "status": "ok <bad>",
+            "summary": [
                 {"label": "node", "value": "<script>alert(1)</script>"},
                 {"label": "count", "value": 3},
             ],
-            steps=[StepEvent(name="locate <x>", status="done", reason="score > 1")],
-            rpg_deltas=[RPGDeltaEvent(node_id="feature<script>", name="Explain", path="a.py")],
-            dep_graph_deltas=[DepGraphDeltaEvent(dep_node_id="a.py:f", path="a.py")],
-            artifacts=[ArtifactEvent(label="plan", path=tmp_path / "plan.json")],
-            verification=[VerificationEvent(name="pytest", status="passed")],
-            user_decisions=[
+            "steps": [StepEvent(name="locate <x>", status="done", reason="score > 1")],
+            "rpg_deltas": [RPGDeltaEvent(node_id="feature<script>", name="Explain", path="a.py")],
+            "dep_graph_deltas": [DepGraphDeltaEvent(dep_node_id="a.py:f", path="a.py")],
+            "code_deltas": [CodeDeltaEvent(file="a.py", change_type="modify", diff="+safe")],
+            "focused_view": {
+                "nodes_view": {
+                    "summary": {"semantic_nodes": 1, "code_nodes": 0, "mappings": 0, "edges": 0, "warnings": 0},
+                    "semantic_nodes": [{"node_id": "feature<script>", "link_id": "rpg-feature-script", "name": "Explain"}],
+                    "code_nodes": [],
+                    "mappings": [],
+                    "edges": [],
+                    "hidden_counts": {},
+                    "warnings": [],
+                }
+            },
+            "artifacts": [ArtifactEvent(label="plan", path=tmp_path / "plan.json")],
+            "verification": [VerificationEvent(name="pytest", status="passed")],
+            "user_decisions": [
                 UserDecisionEvent(
                     decision="apply <unsafe>",
                     branch="rpg-edit/<branch>",
@@ -62,9 +74,9 @@ def test_common_run_report_write_command_report_escapes_content_and_writes_secti
                     test_status="passed <ok>",
                 )
             ],
-            evidence={"raw": "<script>evil()</script>"},
-            timestamp="2026-06-30T12:34:56Z",
-        ),
+            "evidence": {"raw": "<script>evil()</script>"},
+            "timestamp": "2026-06-30T12:34:56Z",
+        },
         report_dir=tmp_path,
     )
 
@@ -73,10 +85,10 @@ def test_common_run_report_write_command_report_escapes_content_and_writes_secti
     html = report.read_text(encoding="utf-8")
     section_order = [
         "Summary",
-        "Stage timeline",
-        "Safety boundary",
         "Focused graph",
         "What changed?",
+        "Stage timeline",
+        "Safety boundary",
         "Artifact links",
         "Evidence JSON",
     ]
@@ -467,6 +479,8 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "a.py:f&lt;script&gt;" in html
     assert "a.py&lt;script&gt;" in html
     assert "maps because &lt;reason&gt;" in html
+    assert "<details><summary>Warnings</summary>" in html
+    assert "<details open><summary>Warnings</summary>" not in html
     assert "Missing &lt;mapping&gt;" in html
     assert "missing_mapping" in html
     assert "missing_reason" in html

From 74af2005ae285fce9e265a8a020da698f1102126 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 02:45:29 +0000
Subject: [PATCH 44/56] rpg_edit: In _render_page() CSS around lines 424-428,
 add a persistent

---
 CoderMind/scripts/common/run_report.py | 11 ++++++++++-
 CoderMind/tests/test_run_report.py     |  9 +++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 227ba5f..7e8085e 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -423,6 +423,8 @@ def _render_page(
 .focused-graph-link.source-dep-graph {{ stroke-dasharray:5 3; }}
 .focused-graph-node {{ cursor:pointer; transition:opacity .15s ease; }}
 .focused-graph-node circle {{ fill:#3b82f6; stroke:#e2e8f0; stroke-width:2; transition:stroke .15s ease, stroke-width .15s ease; }}
+.focused-graph-node.non-focused circle {{ fill:#cbd5e1; }}
+.focused-graph-node.non-focused text {{ fill:#94a3b8; }}
 .focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle {{ stroke:#f8fafc; stroke-width:3; }}
 .focused-graph-node.search-match circle {{ stroke:#f59e0b; stroke-width:3; }}
 .focused-graph-node.dimmed {{ opacity:.18; }}
@@ -1377,6 +1379,13 @@ def _focused_graph_runtime() -> str:
   const expandedNodeIds = new Set(list(defaultFocus.default_expanded_node_ids || defaultFocus.expanded_node_ids).map(text).filter(Boolean));
   const focusedPathNodeIds = new Set(list(defaultFocus.focused_path_node_ids).map(text).filter(Boolean));
   const defaultExpandedIds = new Set([rootHierarchyId, ...expandedNodeIds]);
+  const isDefaultFocused = d => {
+    const data = d?.data || {};
+    return [d?.id, data.id, data.link_id, data.node_id, data.dep_node_id]
+      .map(text)
+      .filter(Boolean)
+      .some(id => focusedNodeIds.has(id) || focusedCodeLinkIds.has(id));
+  };
   let showEdges = defaultShowEdges;
   let query = '';
   let selectedId = null;
@@ -1775,7 +1784,7 @@ def _focused_graph_runtime() -> str:
     const nodeUpdate = nodeEnter.merge(node);
     nodeUpdate.transition().duration(250).attr('transform', d => `translate(${d.y},${d.x})`);
     nodeUpdate
-      .attr('class', d => `focused-graph-node${d.id === selectedId ? ' selected' : ''}${focusedNodeIds.has(d.id) || focusedCodeLinkIds.has(d.id) ? ' focused' : ''}${nodeMatches(d) ? ' search-match' : ''}${selectedId && d.id !== selectedId && !currentRelationEdges.some(edge => edge._source.id === d.id || edge._target.id === d.id) ? ' dimmed' : ''}`);
+      .attr('class', d => `focused-graph-node${d.id === selectedId ? ' selected' : ''}${isDefaultFocused(d) ? ' focused' : ' non-focused'}${nodeMatches(d) ? ' search-match' : ''}${selectedId && d.id !== selectedId && !currentRelationEdges.some(edge => edge._source.id === d.id || edge._target.id === d.id) ? ' dimmed' : ''}`);
     nodeUpdate.select('circle').attr('r', d => d._children ? 6 : (d.children ? 5 : 4));
     nodeUpdate.select('text')
       .attr('x', d => d.children || d._children ? -10 : 10)
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 0ba8601..48d9e5b 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -415,6 +415,9 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "dblclick" in html
     assert "focused-graph-layer" in html
     assert "focused-graph-node.selected" in html
+    assert ".focused-graph-node.non-focused circle { fill:#cbd5e1; }" in html
+    assert ".focused-graph-node.non-focused text { fill:#94a3b8; }" in html
+    assert ".focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle" in html
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
@@ -535,6 +538,12 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "focused-graph-root" in default_focus["default_expanded_node_ids"]
     assert "rpg-n1-script" in default_focus["focused_path_node_ids"]
     assert "context-callee-script" not in default_focus["default_expanded_node_ids"]
+    assert "const isDefaultFocused = d =>" in html
+    assert "${isDefaultFocused(d) ? ' focused' : ' non-focused'}" in html
+    assert "focusedNodeIds.has(id) || focusedCodeLinkIds.has(id)" in html
+    assert "focusedNodeIds.has(d.id) || focusedCodeLinkIds.has(d.id)" not in html
+    assert "rpg-background" not in default_focus["focused_tree_node_ids"]
+    assert "context-callee-script" not in default_focus["focused_tree_node_ids"]
     assert graph_payload["hidden_counts"] == {"callers": 3}
     inspector_json = html.split("<summary>Inspector JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
     assert "focused_graph" in inspector_json

From 96a386e82ee62734f07215cc5d3fd00e6139459f Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 03:39:16 +0000
Subject: [PATCH 45/56] rpg_edit: In _render_page() CSS at lines 391-433,
 convert .focused-gra

---
 CoderMind/scripts/common/run_report.py | 50 ++++++++++++++++++++------
 CoderMind/tests/test_run_report.py     | 23 +++++++++---
 2 files changed, 58 insertions(+), 15 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 7e8085e..1f31926 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -389,13 +389,13 @@ def _render_page(
 .focus-links {{ display:flex; flex-wrap:wrap; gap:6px; }}
 .focus-link {{ border:1px solid var(--line); border-radius:999px; padding:2px 8px; background:#fff; font-size:12px; }}
 .focused-graph-section {{ overflow-x:hidden; }}
-.focused-graph-toolbar {{ display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a; color:#e5e7eb; }}
+.focused-graph-stage {{ border:1px solid #334155; border-radius:12px; background:#0f172a; height:clamp(520px,72vh,820px); position:relative; overflow:hidden; }}
+.focused-graph-svg {{ display:block; width:100%; height:100%; cursor:grab; touch-action:none; }}
+.focused-graph-svg:active {{ cursor:grabbing; }}
+.focused-graph-toolbar {{ position:absolute; top:14px; left:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; align-items:center; max-width:calc(100% - 28px); margin:0; padding:10px; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.92); color:#e5e7eb; box-shadow:0 14px 32px rgba(2,6,23,.35); }}
 .focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb; padding:6px 10px; font:inherit; }}
 .focused-graph-toolbar input::placeholder {{ color:#94a3b8; }}
 .focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:#cbd5e1; }}
-.focused-graph-stage {{ border:1px solid #334155; border-radius:12px; background:#0f172a; min-height:680px; position:relative; overflow:hidden; }}
-.focused-graph-svg {{ display:block; width:100%; height:680px; cursor:grab; touch-action:none; }}
-.focused-graph-svg:active {{ cursor:grabbing; }}
 .focused-graph-detail {{ position:absolute; top:14px; right:14px; z-index:2; width:min(320px,calc(100% - 28px)); max-height:calc(100% - 28px); overflow:auto; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.94); color:#e5e7eb; padding:12px; box-shadow:0 18px 40px rgba(2,6,23,.35); }}
 .focused-graph-detail h3 {{ margin:0 0 8px; font-size:15px; color:#f8fafc; overflow-wrap:anywhere; }}
 .focused-graph-detail dl {{ margin:0; display:grid; gap:8px; }}
@@ -430,7 +430,7 @@ def _render_page(
 .focused-graph-node.dimmed {{ opacity:.18; }}
 .focused-graph-node.hidden {{ display:none; }}
 .focused-graph-fallback {{ margin:12px; padding:12px; border:1px dashed #475569; border-radius:10px; background:#1e293b; color:#cbd5e1; }}
-.focused-graph-legend {{ display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a; }}
+.focused-graph-legend {{ position:absolute; left:14px; bottom:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; max-width:calc(100% - 28px); margin:0; padding:10px; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.92); box-shadow:0 14px 32px rgba(2,6,23,.35); }}
 .legend-item {{ display:inline-flex; gap:6px; align-items:center; color:#cbd5e1; font-size:13px; }}
 .legend-swatch {{ width:10px; height:10px; border-radius:999px; display:inline-block; border:1px solid #475569; flex:0 0 auto; }}
 .legend-line {{ width:28px; height:0; border-radius:0; border:0; border-top:2px solid var(--line); background:transparent; }}
@@ -1352,14 +1352,25 @@ def _focused_graph_runtime() -> str:
   if (!section) return;
   const dataEl = section.querySelector('[data-focused-graph-json]');
   const svg = section.querySelector('[data-focused-graph-svg]');
+  const stage = section.querySelector('.focused-graph-stage');
   const fallback = section.querySelector('[data-focused-graph-fallback]');
   const statusEl = section.querySelector('[data-focused-graph-status]');
   const detailEl = section.querySelector('[data-focused-graph-detail]');
   if (!window.d3 || !dataEl || !svg) return;
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
-  const width = Number(svg.getAttribute('width')) || 960;
-  const height = Number(svg.getAttribute('height')) || 680;
+  const svgSelection = d3.select(svg);
+  let width = 960;
+  let height = 680;
+
+  function refreshGraphViewport() {
+    const svgBox = svg.getBoundingClientRect();
+    const stageBox = stage ? stage.getBoundingClientRect() : {width: 0, height: 0};
+    width = Math.max(320, Math.round(svgBox.width || stageBox.width || svg.clientWidth || 960));
+    height = Math.max(360, Math.round(svgBox.height || stageBox.height || svg.clientHeight || 680));
+    svgSelection.attr('viewBox', `0 0 ${width} ${height}`);
+  }
+  refreshGraphViewport();
   const defaultFocus = data.default_focus || {};
   const defaultShowEdges = defaultFocus.show_edges !== false;
   const text = value => value === undefined || value === null ? '' : String(value);
@@ -1425,7 +1436,6 @@ def _focused_graph_runtime() -> str:
 
   const relationEdges = list(data.relation_edges || data.links).filter(edge => text(edge.relation) !== 'contains');
   const treemap = d3.tree().nodeSize([28, 250]);
-  const svgSelection = d3.select(svg).attr('viewBox', `0 0 ${width} ${height}`);
   svgSelection.selectAll('*').remove();
   const graphLayer = svgSelection.append('g').attr('class', 'focused-graph-layer').attr('transform', 'translate(80,40)');
   const relationLayer = graphLayer.append('g').attr('class', 'focused-graph-relation-links');
@@ -1807,6 +1817,25 @@ def _focused_graph_runtime() -> str:
     currentNodes.forEach(d => { d.x0 = d.x; d.y0 = d.y; });
   }
 
+  let resizeFrame = null;
+  function scheduleResize() {
+    if (resizeFrame !== null) return;
+    resizeFrame = window.requestAnimationFrame(() => {
+      resizeFrame = null;
+      const previousWidth = width;
+      const previousHeight = height;
+      refreshGraphViewport();
+      if (width !== previousWidth || height !== previousHeight) update(root);
+    });
+  }
+  if (window.ResizeObserver) {
+    const resizeObserver = new ResizeObserver(scheduleResize);
+    resizeObserver.observe(svg);
+    if (stage) resizeObserver.observe(stage);
+  } else {
+    window.addEventListener('resize', scheduleResize);
+  }
+
   section.querySelector('[data-action="reset"]')?.addEventListener('click', resetDefault);
   section.querySelector('[data-action="expand-all"]')?.addEventListener('click', expandAll);
   section.querySelector('[data-action="depth-plus"]')?.addEventListener('click', expandDepth);
@@ -1872,10 +1901,11 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     )
     return (
         '<section class="focused-graph-section" data-focused-graph><h2>Focused graph</h2>'
-        f"{summary_html}{controls}{legend}"
+        f"{summary_html}"
         f"<script type=\"application/json\" data-focused-graph-json>{graph_json}</script>"
         '<div class="focused-graph-stage">'
-        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view" width="960" height="680"></svg>'
+        f"{controls}{legend}"
+        '<svg class="focused-graph-svg" data-focused-graph-svg role="img" aria-label="Focused graph view"></svg>'
         '<aside class="focused-graph-detail" data-focused-graph-detail aria-live="polite"><h3>Node details</h3><p class="empty">Select a node to inspect metadata.</p></aside>'
         f'<div class="focused-graph-fallback" data-focused-graph-fallback{fallback_hidden}>Static focused graph fallback is available when D3 cannot run.{d3_missing_note}</div>'
         '</div>'
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 48d9e5b..2f29f22 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -381,7 +381,10 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     html = report.read_text(encoding="utf-8")
     assert "Focused graph" in html
     assert "main { max-width:1440px;" in html
-    assert "height=\"680\"" in html
+    assert "height=\"680\"" not in html
+    assert "width=\"960\"" not in html
+    assert '<div class="focused-graph-stage"><div class="focused-graph-toolbar">' in html
+    assert '<div class="focused-graph-legend" aria-label="Focused graph legend">' in html
     assert "Focused nodes map" not in html
     assert "semantic-code impact chain" not in html
     assert html.count("<h2>Focused graph</h2>") == 1
@@ -421,16 +424,26 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
-    assert ".focused-graph-stage { border:1px solid #334155; border-radius:12px; background:#0f172a; min-height:680px;" in html
-    assert ".focused-graph-svg { display:block; width:100%; height:680px;" in html
-    assert ".focused-graph-toolbar { display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin:10px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
+    assert ".focused-graph-stage { border:1px solid #334155; border-radius:12px; background:#0f172a; height:clamp(520px,72vh,820px);" in html
+    assert ".focused-graph-svg { display:block; width:100%; height:100%;" in html
+    assert ".focused-graph-toolbar { position:absolute; top:14px; left:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; align-items:center; max-width:calc(100% - 28px); margin:0;" in html
     assert ".focused-graph-toolbar button, .focused-graph-toolbar input { border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb;" in html
-    assert ".focused-graph-legend { display:flex; flex-wrap:wrap; gap:8px; margin:8px 0 12px; padding:10px; border:1px solid #334155; border-radius:12px; background:#0f172a;" in html
+    assert ".focused-graph-legend { position:absolute; left:14px; bottom:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; max-width:calc(100% - 28px); margin:0;" in html
     assert ".focused-graph-detail { position:absolute; top:14px; right:14px;" in html
     assert "rootHierarchyId" in html
     assert "defaultExpandedIds" in html
     assert "visibleEndpoint" in html
     assert "updateStatus" in html
+    assert "const svgSelection = d3.select(svg);" in html
+    assert "function refreshGraphViewport()" in html
+    assert "svg.getBoundingClientRect()" in html
+    assert "stage.getBoundingClientRect()" in html
+    assert "svgSelection.attr('viewBox', `0 0 ${width} ${height}`);" in html
+    assert "window.ResizeObserver" in html
+    assert "new ResizeObserver(scheduleResize)" in html
+    assert "window.requestAnimationFrame" in html
+    assert "Number(svg.getAttribute('width'))" not in html
+    assert "Number(svg.getAttribute('height'))" not in html
     assert "const visible = showEdges ? currentRelationEdges.length : 0;" in html
     assert "const total = relationEdges.length;" in html
     assert "statusEl.textContent = `Visible relation edges: ${visible}/${total}`;" in html

From 63b24332a575823a2aa76636a5d0f55b1e267995 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 04:30:50 +0000
Subject: [PATCH 46/56] rpg_edit: In _render_page() CSS at lines 424-428, set
 the selected/act

---
 CoderMind/scripts/common/run_report.py | 33 ++------------------------
 CoderMind/tests/test_run_report.py     | 25 +++++++++++--------
 2 files changed, 17 insertions(+), 41 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 1f31926..2fcd156 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -425,7 +425,7 @@ def _render_page(
 .focused-graph-node circle {{ fill:#3b82f6; stroke:#e2e8f0; stroke-width:2; transition:stroke .15s ease, stroke-width .15s ease; }}
 .focused-graph-node.non-focused circle {{ fill:#cbd5e1; }}
 .focused-graph-node.non-focused text {{ fill:#94a3b8; }}
-.focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle {{ stroke:#f8fafc; stroke-width:3; }}
+.focused-graph-node.selected circle, .focused-graph-node.active circle, .focused-graph-node.focused circle {{ stroke:#3b82f6; stroke-width:3; }}
 .focused-graph-node.search-match circle {{ stroke:#f59e0b; stroke-width:3; }}
 .focused-graph-node.dimmed {{ opacity:.18; }}
 .focused-graph-node.hidden {{ display:none; }}
@@ -438,7 +438,7 @@ def _render_page(
 .legend-tree-link {{ border-top-color:#cbd5e1; border-top-width:1.4px; }}
 .legend-semantic-edge {{ border-top-color:#7c3aed; }}
 .legend-dependency-edge, .legend-imports-edge {{ border-top-color:#ea580c; }}
-.legend-invokes-edge, .legend-caller-edge, .legend-callee-edge {{ border-top-color:#16a34a; }}
+.legend-invokes-edge {{ border-top-color:#16a34a; }}
 .legend-inherits-edge {{ border-top-color:#9333ea; }}
 .legend-references-edge {{ border-top-color:#2563eb; }}
 .legend-dep-graph-edge {{ border-top-style:dashed; }}
@@ -1646,27 +1646,6 @@ def _focused_graph_runtime() -> str:
     walkAll(root, d => { if (nodeMatches(d)) openAncestors(d); });
   }
 
-  function expandAll() {
-    walkAll(root, d => { if (d._children) { d.children = d._children; d._children = null; } });
-    update(root);
-  }
-
-  function expandDepth() {
-    let minDepth = Infinity;
-    walkAll(root, d => { if (d._children && d.depth < minDepth) minDepth = d.depth; });
-    if (minDepth === Infinity) return;
-    walkAll(root, d => { if (d._children && d.depth === minDepth) { d.children = d._children; d._children = null; } });
-    update(root);
-  }
-
-  function collapseDepth() {
-    let maxDepth = -1;
-    walkAll(root, d => { if (d.children && d.children.length && d.depth > maxDepth) maxDepth = d.depth; });
-    if (maxDepth <= 0) return;
-    walkAll(root, d => { if (d.children && d.children.length && d.depth === maxDepth) { d._children = d.children; d.children = null; } });
-    update(root);
-  }
-
   function resetDefault() {
     query = '';
     selectedId = null;
@@ -1837,9 +1816,6 @@ def _focused_graph_runtime() -> str:
   }
 
   section.querySelector('[data-action="reset"]')?.addEventListener('click', resetDefault);
-  section.querySelector('[data-action="expand-all"]')?.addEventListener('click', expandAll);
-  section.querySelector('[data-action="depth-plus"]')?.addEventListener('click', expandDepth);
-  section.querySelector('[data-action="depth-minus"]')?.addEventListener('click', collapseDepth);
   section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; update(root); });
   section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = text(event.target.value).toLowerCase(); update(root); });
   update(root);
@@ -1877,9 +1853,6 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     controls = (
         '<div class="focused-graph-toolbar">'
         '<button type="button" data-action="reset">Reset default</button>'
-        '<button type="button" data-action="expand-all">Expand all</button>'
-        '<button type="button" data-action="depth-plus" title="Expand hierarchy depth">+1</button>'
-        '<button type="button" data-action="depth-minus" title="Collapse hierarchy depth">-1</button>'
         '<label><input type="checkbox" data-action="edges" checked> Edges</label>'
         '<input type="search" data-action="search" placeholder="Search nodes" aria-label="Search focused graph nodes">'
         f'<span class="badge" data-focused-graph-status>Visible relation edges: 0/{relation_edge_total}</span>'
@@ -1895,8 +1868,6 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         '<span class="legend-item"><span class="legend-swatch legend-line legend-imports-edge legend-dep-graph-edge"></span>imports</span>'
         '<span class="legend-item"><span class="legend-swatch legend-line legend-inherits-edge"></span>inherits</span>'
         '<span class="legend-item"><span class="legend-swatch legend-line legend-references-edge"></span>references</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-line legend-caller-edge"></span>caller</span>'
-        '<span class="legend-item"><span class="legend-swatch legend-line legend-callee-edge"></span>callee</span>'
         '</div>'
     )
     return (
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 2f29f22..84470e4 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -399,8 +399,9 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "https://d3js.org v7.9.0" in html
     assert "<script src=" not in html
     assert "data-action=\"reset\"" in html
-    assert "data-action=\"depth-plus\"" in html
-    assert "data-action=\"depth-minus\"" in html
+    assert "data-action=\"expand-all\"" not in html
+    assert "data-action=\"depth-plus\"" not in html
+    assert "data-action=\"depth-minus\"" not in html
     assert "data-action=\"edges\"" in html
     assert "data-action=\"search\"" in html
     assert "data-focused-graph-status" in html
@@ -410,8 +411,9 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "Select a node to inspect metadata." in html
     assert "Visible relation edges: 0/3" in html
     assert "Reset" in html
-    assert "+1" in html
-    assert "-1" in html
+    assert "Expand all" not in html
+    assert ">+1</button>" not in html
+    assert ">-1</button>" not in html
     assert "Edges" in html
     assert "Search nodes" in html
     assert "d3.zoom()" in html
@@ -461,16 +463,19 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "if (!isCodeContextDetail(detail)) addValueRow(rows, 'Feature path', detail.breadcrumb_path || detail.feature_path);" in html
     assert "item.source" not in html
     assert "SHOULD NOT RENDER FROM CODE" in html
-    assert "expandDepth" in html
-    assert "collapseDepth" in html
-    assert "Expand hierarchy depth" in html
-    assert "Collapse hierarchy depth" in html
+    assert "expandAll" not in html
+    assert "expandDepth" not in html
+    assert "collapseDepth" not in html
+    assert "Expand hierarchy depth" not in html
+    assert "Collapse hierarchy depth" not in html
     assert "d3.zoomIdentity" in html
     assert "Static focused graph fallback is available when D3 cannot run." in html
-    for label in ("Tree link", "RPG semantic edge", "dep_graph dependency edge", "invokes", "imports", "inherits", "references", "caller", "callee"):
+    for label in ("Tree link", "RPG semantic edge", "dep_graph dependency edge", "invokes", "imports", "inherits", "references"):
         assert label in html
-    for klass in ("legend-tree-link", "legend-invokes-edge", "legend-imports-edge", "legend-inherits-edge", "legend-references-edge", "legend-caller-edge", "legend-callee-edge"):
+    for klass in ("legend-tree-link", "legend-invokes-edge", "legend-imports-edge", "legend-inherits-edge", "legend-references-edge"):
         assert klass in html
+    assert "legend-caller-edge" not in html
+    assert "legend-callee-edge" not in html
     assert "semantic_nodes" in html
     assert "code_nodes" in html
     assert "mappings" in html

From 83b26d081d5a0f0c90486f7ec4f7c465f6174306 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 05:19:48 +0000
Subject: [PATCH 47/56] rpg_edit: In _focused_graph_default_focus() around
 lines 785-931, rest

---
 CoderMind/scripts/rpg_edit/review.py        | 17 +++--------------
 CoderMind/scripts/update_graphs.py          | 12 ++++++------
 CoderMind/tests/test_encode_commands.py     | 10 +++++++++-
 CoderMind/tests/test_rpg_edit_run_report.py | 16 +++++++++++-----
 4 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 4357512..d157911 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -785,13 +785,10 @@ def _focused_graph_default_focus(
     focused_semantic_links = [
         str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
         for node in semantic_nodes
-        if node.get("selected")
-        or node.get("changed")
+        if node.get("changed")
         or node.get("changed_files")
         or node.get("diff_anchor")
-        or node.get("warning_types")
-        or node.get("mapping_status")
-        or node.get("locate_status")
+        or node.get("change")
         or node.get("apply_action")
     ]
     code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
@@ -923,12 +920,7 @@ def owner_feature_links(edge: Dict[str, Any]) -> List[str]:
         if node.get("changed") or node.get("changed_files") or node.get("diff_anchor"):
             changed_code_links.append(link_id)
             changed_feature_links.extend(_listify(node.get("mapped_rpg_link_ids")) + code_to_feature_links.get(link_id, []))
-    warning_links = []
-    for warning in warnings:
-        warning_links.extend(_listify(warning.get("node_link_id")) + _listify(warning.get("code_link_id")))
-    node_link_ids = _ordered_unique(focused_semantic_links + changed_feature_links + changed_code_links + warning_links)
-    if not node_link_ids:
-        node_link_ids = _ordered_unique(focused_semantic_links or semantic_links + code_links)
+    node_link_ids = _ordered_unique(focused_semantic_links + changed_feature_links + changed_code_links)
 
     expanded_node_ids: List[Any] = ["focused-graph-root"]
     focused_path_node_ids: List[Any] = []
@@ -955,9 +947,6 @@ def focus_tree_link(link_id: Any) -> None:
 
     for link_id in node_link_ids:
         focus_tree_link(link_id)
-    if not focused_tree_node_ids:
-        for link_id in semantic_links:
-            focus_tree_link(link_id)
 
     expanded_node_ids = _ordered_unique(expanded_node_ids)
     focused_path_node_ids = _ordered_unique(focused_path_node_ids)
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index a397e27..7c0fb4d 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -637,6 +637,11 @@ def _focused_graph_default_focus(
     warnings: list[dict[str, Any]],
 ) -> dict[str, Any]:
     semantic_links = [str(node.get("link_id") or _node_link_id("rpg", node.get("node_id"))) for node in semantic_nodes]
+    focused_semantic_links = [
+        str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        for node in semantic_nodes
+        if node.get("changed") or node.get("changed_files") or node.get("diff_anchor") or node.get("change")
+    ]
     code_links = [str(node.get("link_id") or _node_link_id("code", node.get("node_id") or node.get("dep_node_id"))) for node in code_nodes]
     rpg_link_by_node_id = {
         str(node.get("node_id")): str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
@@ -729,12 +734,7 @@ def remember_path(alias: Any, path_ids: list[str]) -> None:
         if node.get("changed") or node.get("changed_files") or node.get("diff_anchor"):
             changed_code_links.append(link_id)
             changed_feature_links.extend(_listify(node.get("mapped_rpg_link_ids")) + code_to_feature_links.get(link_id, []))
-    warning_links: list[Any] = []
-    for warning in warnings:
-        warning_links.extend(_listify(warning.get("node_link_id")) + _listify(warning.get("code_link_id")))
-    node_link_ids = _ordered_unique_text(semantic_links + changed_feature_links + changed_code_links + warning_links)
-    if not node_link_ids:
-        node_link_ids = _ordered_unique_text(semantic_links + code_links)
+    node_link_ids = _ordered_unique_text(focused_semantic_links + changed_feature_links + changed_code_links)
 
     expanded_node_ids: list[Any] = ["focused-graph-root"]
     focused_path_node_ids: list[Any] = []
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 71be4a7..324e88f 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -578,7 +578,11 @@ def fake_write_command_report(run):
     assert nodes_view["graph_context"]["rpg_nodes"] == 4504
     assert nodes_view["graph_context"]["dep_edges"] == 5498
     assert nodes_view["graph_context"]["semantic_delta"] == 3
-    assert "rpg-feature_a" in nodes_view["default_focus"]["node_link_ids"]
+    default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
+    assert "rpg-feature_a" in default_node_link_ids
+    assert "code-scripts-a.py" in default_node_link_ids
+    assert "code-scripts-a.py-f" in default_node_link_ids
+    assert "code-tests-test_a.py" in default_node_link_ids
     assert "code-scripts-a.py-f" in nodes_view["default_focus"]["focused_code_link_ids"]
     assert "edge-scripts-a.py-f-imports-tests-test_a.py" in nodes_view["default_focus"]["edge_link_ids"]
     assert "code-tests-test_a.py" in nodes_view["default_focus"]["relation_endpoint_link_ids"]
@@ -660,6 +664,10 @@ def fake_write_command_report(run):
         "children": [],
     }
     assert nodes_view["default_focus"]["node_link_ids"] == []
+    assert nodes_view["default_focus"]["focused_node_ids"] == []
+    assert nodes_view["default_focus"]["focused_tree_node_ids"] == []
+    assert nodes_view["default_focus"]["focused_code_link_ids"] == []
+    assert nodes_view["default_focus"]["relation_endpoint_link_ids"] == []
     assert nodes_view["default_focus"]["semantic_node_ids"] == []
     assert nodes_view["default_focus"]["code_node_ids"] == []
     assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index e673fed..8326e2d 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -366,9 +366,13 @@ def fake_write_command_report(run):
         assert "rpg-n3" in hierarchy_text
         assert "Node / Context Node" in hierarchy_text
         assert '"feature_path": "context.py"' not in hierarchy_text
-        assert nodes_view["default_focus"]["node_link_ids"]
-        assert "rpg-n1" in nodes_view["default_focus"]["node_link_ids"]
-        assert "rpg-n3" not in nodes_view["default_focus"]["node_link_ids"]
+        default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
+        assert default_node_link_ids == ["rpg-n1", "code-a.py-f"]
+        assert "rpg-n2" not in default_node_link_ids
+        assert "rpg-n3" not in default_node_link_ids
+        focused_tree_node_ids = nodes_view["default_focus"]["focused_tree_node_ids"]
+        assert "rpg-n2" not in focused_tree_node_ids
+        assert "rpg-n3" not in focused_tree_node_ids
         assert nodes_view["default_focus"]["edge_depth"] == 1
         assert nodes_view["default_focus"]["show_edges"] is True
         assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
@@ -608,8 +612,10 @@ def fake_write_command_report(run):
         assert "rpg-background" in hierarchy_text
         assert '"feature_path": "Planned Node"' in hierarchy_text
         assert '"feature_path": "scripts/common/run_report.py"' not in hierarchy_text
-        assert nodes_view["default_focus"]["node_link_ids"] == ["rpg-planned", "code-scripts-common-run_report.py-_render_artifacts"]
-        assert "rpg-background" not in nodes_view["default_focus"]["node_link_ids"]
+        default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
+        assert default_node_link_ids == ["rpg-planned", "code-scripts-common-run_report.py-_render_artifacts"]
+        assert "rpg-background" not in default_node_link_ids
+        assert "rpg-background" not in nodes_view["default_focus"]["focused_tree_node_ids"]
         assert nodes_view["default_focus"]["edge_depth"] == 1
         assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
         assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]

From 10f94030654ab7ca85bafcf252acbf71e1da90a5 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 05:30:30 +0000
Subject: [PATCH 48/56] review: fix issues found in impact review

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/common/run_report.py | 6 ++++--
 CoderMind/scripts/rpg_edit/review.py   | 6 +++++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 2fcd156..8fc8135 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -1436,8 +1436,10 @@ def _focused_graph_runtime() -> str:
 
   const relationEdges = list(data.relation_edges || data.links).filter(edge => text(edge.relation) !== 'contains');
   const treemap = d3.tree().nodeSize([28, 250]);
+  const graphOffsetX = 80;
+  const graphOffsetY = 96;
   svgSelection.selectAll('*').remove();
-  const graphLayer = svgSelection.append('g').attr('class', 'focused-graph-layer').attr('transform', 'translate(80,40)');
+  const graphLayer = svgSelection.append('g').attr('class', 'focused-graph-layer').attr('transform', `translate(${graphOffsetX},${graphOffsetY})`);
   const relationLayer = graphLayer.append('g').attr('class', 'focused-graph-relation-links');
   const treeLinkLayer = graphLayer.append('g').attr('class', 'focused-graph-tree-links');
   const nodeLayer = graphLayer.append('g').attr('class', 'focused-graph-nodes');
@@ -1656,7 +1658,7 @@ def _focused_graph_runtime() -> str:
     const edges = section.querySelector('[data-action="edges"]');
     if (edges) edges.checked = showEdges;
     renderFocusedGraphDetail(null);
-    svgSelection.transition().duration(150).call(zoom.transform, d3.zoomIdentity.translate(80, 40));
+    svgSelection.transition().duration(150).call(zoom.transform, d3.zoomIdentity.translate(graphOffsetX, graphOffsetY));
     update(root);
   }
 
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index d157911..a500aea 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -1635,7 +1635,11 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
             + [current_dep_nodes.get(dep_id, {}).get("path") for dep_id in mapped_dep_ids]
         )
         affected_files = _ordered_unique(_listify(impact.get("affected_files")) + relation_paths)
-        relevant_files = set(affected_files or relation_paths or changed_files)
+        relevant_files = set(_ordered_unique(affected_files + [
+            candidate.get("path"),
+            candidate.get("meta_path"),
+            current_node.get("path"),
+        ]))
         relevant_deltas = [delta for delta in code_deltas if _code_delta_file(delta) in relevant_files]
         changed_for_node = _ordered_unique([_code_delta_file(delta) for delta in relevant_deltas])
         focus_reason = _focus_reason(candidate, impact)

From aeb48b7fd9c83b0e298cd6879de401ab66defe5f Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 08:55:38 +0000
Subject: [PATCH 49/56] llm_client: clarify AI CLI subprocess errors

Make timeout and empty-response failures identify the AI CLI subprocess so logs point to the failing boundary.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/common/llm_client.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/CoderMind/scripts/common/llm_client.py b/CoderMind/scripts/common/llm_client.py
index e9fddd7..4628e48 100644
--- a/CoderMind/scripts/common/llm_client.py
+++ b/CoderMind/scripts/common/llm_client.py
@@ -419,8 +419,8 @@ def generate(
                         self.logger.warning(error)
                         
                 except subprocess.TimeoutExpired:
-                    error = f"LLM call timed out after {timeout}s"
-                    self.logger.warning(f"LLM call timed out (attempt {attempt + 1})")
+                    error = f"AI CLI subprocess timed out after {timeout}s"
+                    self.logger.warning(f"AI CLI subprocess timed out (attempt {attempt + 1})")
                 except Exception as e:
                     error = str(e)
                     self.logger.warning(f"LLM call error: {e}")
@@ -465,8 +465,8 @@ def generate(
                 self.logger.warning(f"Failed to record LLM interaction completion: {e}")
         
         if not response:
-            raise RuntimeError(f"Failed to get response from LLM after {max_retries} retries: {error}")
-        
+            raise RuntimeError(f"AI CLI did not return a response after {max_retries} attempts: {error}")
+
         return response
     
     def generate_with_record(

From 31a3e8e4bc1bb5da60d1614fc5d1d49b0f20b1f4 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 08:55:55 +0000
Subject: [PATCH 50/56] rpg_edit: focus graph counts on modified nodes

Filter focused report nodes through diff hunk ranges and stop treating adjacent graph context as modified evidence.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/common/diff_ranges.py     | 107 ++++++++++++++++
 CoderMind/scripts/rpg_edit/review.py        | 131 +++++++-------------
 CoderMind/scripts/update_graphs.py          |  52 ++++++--
 CoderMind/tests/test_encode_commands.py     |  55 +++++---
 CoderMind/tests/test_rpg_edit_run_report.py |  32 ++---
 5 files changed, 246 insertions(+), 131 deletions(-)
 create mode 100644 CoderMind/scripts/common/diff_ranges.py

diff --git a/CoderMind/scripts/common/diff_ranges.py b/CoderMind/scripts/common/diff_ranges.py
new file mode 100644
index 0000000..5450614
--- /dev/null
+++ b/CoderMind/scripts/common/diff_ranges.py
@@ -0,0 +1,107 @@
+"""Helpers for matching unified diffs to code entity line ranges."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Mapping, Sequence
+
+_HUNK_RE = re.compile(r"@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+
+
+def _to_int(value: Any) -> int | None:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def merge_line_ranges(ranges: Sequence[tuple[int, int]]) -> list[tuple[int, int]]:
+    ordered = sorted((start, end) for start, end in ranges if start > 0 and end >= start)
+    merged: list[tuple[int, int]] = []
+    for start, end in ordered:
+        if not merged or start > merged[-1][1] + 1:
+            merged.append((start, end))
+        else:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+    return merged
+
+
+def changed_line_ranges_from_diff(diff: Any) -> list[tuple[int, int]]:
+    if not isinstance(diff, str) or "@@" not in diff:
+        return []
+    ranges: list[tuple[int, int]] = []
+    new_line: int | None = None
+    for raw_line in diff.splitlines():
+        match = _HUNK_RE.search(raw_line)
+        if match:
+            new_line = int(match.group(1))
+            continue
+        if new_line is None:
+            continue
+        if raw_line.startswith("\\") or raw_line.startswith("+++") or raw_line.startswith("---"):
+            continue
+        prefix = raw_line[:1]
+        if prefix == "+":
+            ranges.append((new_line, new_line))
+            new_line += 1
+        elif prefix == "-":
+            continue
+        else:
+            new_line += 1
+    return merge_line_ranges(ranges)
+
+
+def changed_line_ranges_by_file(code_deltas: Sequence[Mapping[str, Any]]) -> dict[str, list[tuple[int, int]]]:
+    ranges_by_file: dict[str, list[tuple[int, int]]] = {}
+    for delta in code_deltas:
+        file_path = str(delta.get("file") or delta.get("path") or delta.get("after") or delta.get("before") or "")
+        if not file_path:
+            continue
+        ranges = changed_line_ranges_from_diff(delta.get("diff"))
+        if file_path in ranges_by_file:
+            ranges_by_file[file_path] = merge_line_ranges(ranges_by_file[file_path] + ranges)
+        else:
+            ranges_by_file[file_path] = ranges
+    return ranges_by_file
+
+
+def line_range_from_mapping(row: Mapping[str, Any]) -> tuple[int, int] | None:
+    nested = row.get("line_range") if isinstance(row.get("line_range"), Mapping) else {}
+    start = _to_int(nested.get("start") if nested else None)
+    end = _to_int(nested.get("end") if nested else None)
+    if start is None:
+        start = _to_int(
+            row.get("line_start")
+            or row.get("start_line")
+            or row.get("lineno")
+            or row.get("line")
+            or row.get("start")
+        )
+    if end is None:
+        end = _to_int(row.get("line_end") or row.get("end_line") or row.get("end"))
+    if start is None:
+        return None
+    return (start, end if end is not None else start)
+
+
+def line_range_overlaps_any(line_range: tuple[int, int] | None, ranges: Sequence[tuple[int, int]]) -> bool:
+    if line_range is None or not ranges:
+        return False
+    start, end = line_range
+    return any(start <= range_end and end >= range_start for range_start, range_end in ranges)
+
+
+def row_overlaps_changed_lines(
+    row: Mapping[str, Any],
+    file_path: str,
+    ranges_by_file: Mapping[str, Sequence[tuple[int, int]]],
+) -> bool:
+    return line_range_overlaps_any(line_range_from_mapping(row), ranges_by_file.get(file_path, []))
+
+
+def is_file_level_node(node_id: Any, row: Mapping[str, Any], file_path: str) -> bool:
+    node_id_text = str(node_id or "")
+    node_type = str(row.get("type") or row.get("kind") or "").lower()
+    if node_type in {"file", "module"}:
+        return True
+    return node_id_text == file_path or (":" not in node_id_text and str(row.get("path") or row.get("file") or row.get("module") or "") == file_path)
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index a500aea..168738f 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -36,6 +36,12 @@
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
+from common.diff_ranges import (  # noqa: E402
+    changed_line_ranges_by_file,
+    is_file_level_node,
+    line_range_from_mapping,
+    row_overlaps_changed_lines,
+)
 from common.paths import (  # noqa: E402
     REPO_DIR,
     REPORTS_DIR,
@@ -342,6 +348,31 @@ def _dep_node_path(dep_id: Any) -> str:
     return dep_id_text.split(":", 1)[0] if ":" in dep_id_text else dep_id_text
 
 
+def _modified_dep_ids(
+    dep_ids: List[str],
+    relation_by_dep: Mapping[str, Dict[str, Any]],
+    current_dep_nodes: Mapping[str, Dict[str, Any]],
+    changed_ranges: Mapping[str, List[Tuple[int, int]]],
+    changed_files: List[str],
+) -> List[str]:
+    changed_file_set = set(changed_files)
+    ranged_matches: List[str] = []
+    fallback_matches: List[str] = []
+    for dep_id in dep_ids:
+        relation = relation_by_dep.get(dep_id, {})
+        current = current_dep_nodes.get(dep_id, {})
+        row = {**relation, **current}
+        path = str(current.get("path") or relation.get("path") or _dep_node_path(dep_id))
+        if path not in changed_file_set:
+            continue
+        if line_range_from_mapping(row):
+            if row_overlaps_changed_lines(row, path, changed_ranges):
+                ranged_matches.append(dep_id)
+        elif is_file_level_node(dep_id, row, path):
+            fallback_matches.append(dep_id)
+    return _ordered_unique(ranged_matches or fallback_matches[:1])
+
+
 def _mapped_code_relations(candidate: Dict[str, Any], impact: Dict[str, Any]) -> List[Dict[str, Any]]:
     candidate_dep = {str(dep_id) for dep_id in _listify(candidate.get("dep_nodes"))}
     impact_dep = {str(dep_id) for dep_id in _listify(impact.get("dep_nodes"))}
@@ -1043,7 +1074,7 @@ def _build_nodes_view(
             warnings_by_code.setdefault(str(code_id), []).append(warning)
 
     semantic_nodes: List[Dict[str, Any]] = []
-    semantic_source_nodes = list(all_rpg_by_id.values()) if all_rpg_by_id else primary_rpg_nodes
+    semantic_source_nodes = primary_rpg_nodes
     for node in semantic_source_nodes:
         node_id = str(node.get("node_id") or "")
         is_selected = node_id in selected_rpg_ids
@@ -1506,6 +1537,7 @@ def _feature_evidence_groups(
         + [str(path) for path in _listify(code_result.get("files_modified"))]
         + [str(change.get("file_path")) for change in plan.get("code_changes") or [] if isinstance(change, dict) and change.get("file_path")]
     )
+    changed_ranges = changed_line_ranges_by_file(code_deltas)
     warnings: List[Dict[str, Any]] = []
     warning_keys: set[str] = set()
 
@@ -1531,7 +1563,6 @@ def add_warning(warning_type: str, message: str, **context: Any) -> None:
     mapping_rows_all: List[Dict[str, Any]] = []
     code_node_by_id: Dict[str, Dict[str, Any]] = {}
     all_edges: List[Dict[str, Any]] = []
-    edge_keys: set[Tuple[str, str, str, str]] = set()
     impact_hidden_counts: Dict[str, int] = {}
 
     def count_value(value: Any, fallback: int) -> int:
@@ -1571,48 +1602,6 @@ def add_code_node(dep_id: Any, *, source_feature: Any = None, source: str = "map
             add_warning("stale_graph", "Mapped code node is absent from the current dependency graph", dep_node_id=dep_id_text)
         code_node_by_id[dep_id_text] = row
 
-    def add_edge(edge: Dict[str, Any]) -> None:
-        source_node = edge.get("source_node_id")
-        target_node = edge.get("target_node_id")
-        relation = edge.get("relation") or "dependency"
-        source = edge.get("source") or "impact"
-        if source_node in (None, "") or target_node in (None, ""):
-            return
-        source_text = str(source_node)
-        target_text = str(target_node)
-        relation_text = str(relation)
-        source_text_label = str(source)
-        key = (source_text, target_text, relation_text, source_text_label)
-        if key in edge_keys:
-            return
-        edge_keys.add(key)
-        source_graph = edge.get("source_graph") or ("rpg" if source_text_label == "rpg_semantic" else "dep_graph" if source_text_label == "dep_graph" else source_text_label)
-        row: Dict[str, Any] = {
-            "source_node_id": source_text,
-            "target_node_id": target_text,
-            "relation": relation_text,
-            "source": source_text_label,
-            "source_graph": source_graph,
-            "relation_source": edge.get("relation_source") or source_text_label,
-            "edge_source": edge.get("edge_source") or source_graph,
-        }
-        for key_name in ("rpg_node_id", "neighbor_node_id", "direction", "name", "path", "reason", "status"):
-            _set_if_present(row, key_name, edge.get(key_name))
-        all_edges.append(row)
-
-    def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
-        if isinstance(item, dict):
-            node_id = item.get("dep_node_id") or item.get("node_id") or item.get("id")
-            if node_id in (None, ""):
-                return None
-            row: Dict[str, Any] = {"node_id": str(node_id)}
-            for key_name in ("name", "path", "reason", "status", "type"):
-                _set_if_present(row, key_name, item.get(key_name))
-            return row
-        if item in (None, ""):
-            return None
-        return {"node_id": str(item)}
-
     neighbor_specs = [
         ("callers", "caller", "upstream", "total_callers"),
         ("callees", "callee", "downstream", "total_callees"),
@@ -1630,6 +1619,7 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         relations = _mapped_code_relations(candidate, impact)
         relation_by_dep = {str(row.get("dep_node_id") or row.get("node_id")): row for row in relations if row.get("dep_node_id") or row.get("node_id")}
         mapped_dep_ids = _ordered_unique(list(relation_by_dep) + (current_rpg_to_dep.get(node_id) or []))
+        modified_dep_ids = _modified_dep_ids(mapped_dep_ids, relation_by_dep, current_dep_nodes, changed_ranges, changed_files)
         relation_paths = _ordered_unique(
             [row.get("path") for row in relations]
             + [current_dep_nodes.get(dep_id, {}).get("path") for dep_id in mapped_dep_ids]
@@ -1647,39 +1637,18 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
             add_warning("missing_reason", "Focused view has no explicit selection reason", node_id=node_id)
         if not mapped_dep_ids:
             add_warning("missing_mapping", "Selected RPG node has no mapped code node", node_id=node_id)
+        for dep_id in mapped_dep_ids:
+            if current_graph_available and dep_id not in current_dep_nodes:
+                add_warning("stale_graph", "Mapped code node is absent from the current dependency graph", node_id=node_id, dep_node_id=dep_id)
         if current_graph_available and node_id not in current_rpg_nodes:
             add_warning("stale_graph", "Selected RPG node is absent from the current RPG graph", node_id=node_id)
 
         impact_summary = impact.get("impact_summary") if isinstance(impact.get("impact_summary"), dict) else {}
         node_hidden_counts: Dict[str, int] = {}
-        for impact_key, relation, direction, total_key in neighbor_specs:
+        for impact_key, _relation, _direction, total_key in neighbor_specs:
             items = _listify(impact.get(impact_key))
             total = count_value(impact_summary.get(total_key), len(items))
-            visible = 0
-            for item in items:
-                neighbor = impact_neighbor(item)
-                if not neighbor:
-                    continue
-                visible += 1
-                if relation == "caller":
-                    source_node = neighbor["node_id"]
-                    target_node = node_id
-                else:
-                    source_node = node_id
-                    target_node = neighbor["node_id"]
-                edge_row = {
-                    "source_node_id": source_node,
-                    "target_node_id": target_node,
-                    "relation": relation,
-                    "source": "impact",
-                    "rpg_node_id": node_id,
-                    "neighbor_node_id": neighbor["node_id"],
-                    "direction": direction,
-                }
-                for key_name in ("name", "path", "reason", "status"):
-                    _set_if_present(edge_row, key_name, neighbor.get(key_name))
-                add_edge(edge_row)
-            hidden = max(0, total - visible)
+            hidden = max(0, total)
             if hidden:
                 node_hidden_counts[impact_key] = hidden
                 impact_hidden_counts[impact_key] = impact_hidden_counts.get(impact_key, 0) + hidden
@@ -1713,7 +1682,7 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
         primary_rpg_nodes_all.append(rpg_row)
 
         if mapped_dep_ids:
-            for dep_id in mapped_dep_ids:
+            for dep_id in modified_dep_ids:
                 relation = relation_by_dep.get(dep_id, {})
                 current_dep = current_dep_nodes.get(dep_id, {})
                 path = current_dep.get("path") or relation.get("path")
@@ -1742,20 +1711,6 @@ def impact_neighbor(item: Any) -> Optional[Dict[str, Any]]:
                 mapping_row["changed_files"] = changed_for_node
             mapping_rows_all.append(mapping_row)
 
-    for dep_id, dep_node in current_dep_nodes.items():
-        if dep_node.get("path") in changed_files:
-            add_code_node(dep_id, source="changed_file", fallback_path=dep_node.get("path"))
-
-    selected_rpg_ids = {row.get("node_id") for row in primary_rpg_nodes_all}
-    for edge in current_rpg_edges:
-        if edge.get("source_node_id") in selected_rpg_ids or edge.get("target_node_id") in selected_rpg_ids:
-            add_edge(edge)
-
-    selected_code_ids = set(code_node_by_id)
-    for edge in current_dep_edges:
-        if edge.get("source_node_id") in selected_code_ids or edge.get("target_node_id") in selected_code_ids:
-            add_edge(edge)
-
     primary_rpg_nodes = primary_rpg_nodes_all
     primary_code_nodes_all = list(code_node_by_id.values())
     primary_code_nodes = primary_code_nodes_all
@@ -2569,7 +2524,7 @@ def impact_review(
     impact_path: Optional[Path],
     repo_path: Path,
     max_iterations: int = 3,
-    timeout: int = 600,
+    timeout: int = 1200,
     report_scope: str = "final",
     report_dir: Optional[Path] = None,
     parent_run_id: Optional[str] = None,
@@ -2760,8 +2715,8 @@ def main():
                         help="Repository root path")
     parser.add_argument("--max-iterations", type=int, default=3,
                         help="Maximum review+repair iterations (default: 3)")
-    parser.add_argument("--timeout", type=int, default=600,
-                        help="Sub-agent timeout per iteration in seconds (default: 600)")
+    parser.add_argument("--timeout", type=int, default=1200,
+                        help="Sub-agent timeout per iteration in seconds (default: 1200)")
     parser.add_argument("--report-scope", choices=sorted(_REPORT_SCOPES), default="final",
                         help="HTML report publication scope (default: %(default)s)")
     parser.add_argument("--no-report", action="store_true",
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index 7c0fb4d..4d630a3 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -33,6 +33,12 @@
 if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
+from common.diff_ranges import (  # noqa: E402
+    changed_line_ranges_by_file,
+    is_file_level_node,
+    line_range_from_mapping,
+    row_overlaps_changed_lines,
+)
 from common.paths import REPO_RPG_FILE, DEP_GRAPH_FILE, RPG_HTML_FILE, HOOK_CALLS_LOG  # noqa: E402
 from common.rpg_io import atomic_write_rpg, safe_load_rpg  # noqa: E402
 from common.run_events import (  # noqa: E402
@@ -347,6 +353,26 @@ def _dep_node_matches_file(dep_id: str, attrs: dict[str, Any], file_path: str) -
     return False
 
 
+def _modified_dep_nodes_for_file(
+    dep_items: list[tuple[str, dict[str, Any]]],
+    file_path: str,
+    changed_ranges: dict[str, list[tuple[int, int]]],
+) -> list[tuple[str, dict[str, Any]]]:
+    ranged_matches: list[tuple[str, dict[str, Any]]] = []
+    fallback_matches: list[tuple[str, dict[str, Any]]] = []
+    for dep_id, attrs in dep_items:
+        if not _dep_node_matches_file(dep_id, attrs, file_path):
+            continue
+        if line_range_from_mapping(attrs):
+            if row_overlaps_changed_lines(attrs, file_path, changed_ranges):
+                ranged_matches.append((dep_id, attrs))
+        elif is_file_level_node(dep_id, attrs, file_path):
+            fallback_matches.append((dep_id, attrs))
+    if ranged_matches:
+        return ranged_matches
+    return fallback_matches[:1]
+
+
 def _slug_id(prefix: str, value: Any) -> str:
     raw = str(value or prefix)
     slug = re.sub(r"[^A-Za-z0-9_.-]+", "-", raw).strip(".-_")
@@ -1034,21 +1060,26 @@ def _edge_rows(dep_edges: Any, code_ids: set[str]) -> list[dict[str, Any]]:
     rows: list[dict[str, Any]] = []
     if not isinstance(dep_edges, list):
         return rows
+    changed_states = {"added", "changed", "deleted", "modified", "renamed"}
     for edge in dep_edges:
         if not isinstance(edge, dict):
             continue
+        attrs = edge.get("attrs") if isinstance(edge.get("attrs"), dict) else {}
+        change = str(edge.get("change") or edge.get("change_type") or edge.get("status") or attrs.get("change") or attrs.get("change_type") or "").lower()
+        if change not in changed_states:
+            continue
         source = edge.get("src") or edge.get("source") or edge.get("from")
         target = edge.get("dst") or edge.get("target") or edge.get("to")
-        if source not in code_ids and target not in code_ids:
+        if source not in code_ids or target not in code_ids:
             continue
-        attrs = edge.get("attrs") if isinstance(edge.get("attrs"), dict) else {}
         rows.append({
             "source_node_id": source,
             "target_node_id": target,
             "relation": edge.get("relation") or edge.get("type") or attrs.get("type") or "dependency",
             "source_graph": "dep_graph",
             "edge_source": "dep_graph",
-            "reason": "adjacent to changed code",
+            "reason": "edge changed",
+            "status": change,
         })
     return rows[:50]
 
@@ -1056,6 +1087,7 @@ def _edge_rows(dep_edges: Any, code_ids: set[str]) -> list[dict[str, Any]]:
 def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semantic_total: int) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]]]:
     changed_files = _changed_report_files(result, code_deltas)
     diff_anchors = _diff_anchor_map(code_deltas)
+    changed_ranges = changed_line_ranges_by_file(code_deltas)
     rpg_data = _load_report_rpg(result)
     dep_graph = rpg_data.get("dep_graph") if isinstance(rpg_data.get("dep_graph"), dict) else {}
     dep_to_rpg = rpg_data.get("_dep_to_rpg_map") if isinstance(rpg_data.get("_dep_to_rpg_map"), dict) else {}
@@ -1075,11 +1107,8 @@ def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semanti
 
     dep_items = _dep_node_items(dep_graph.get("nodes") if isinstance(dep_graph, dict) else {})
     for changed_file in changed_files:
-        file_matched = False
-        for dep_id, attrs in dep_items:
-            if not _dep_node_matches_file(dep_id, attrs, changed_file):
-                continue
-            file_matched = True
+        modified_dep_nodes = _modified_dep_nodes_for_file(dep_items, changed_file, changed_ranges)
+        for dep_id, attrs in modified_dep_nodes:
             if dep_id in matched_dep_ids:
                 continue
             mapped_rpg_ids = _ordered_unique_text(_listify(attrs.get("rpg_nodes")) + _listify(dep_to_rpg.get(dep_id)))
@@ -1096,14 +1125,15 @@ def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semanti
                     "dep_node_id": dep_id,
                     "status": "mapped",
                     "state": "mapped",
-                    "source": "rpg_json",
+                    "source": "modified_code_range",
                     "path": _dep_node_path(dep_id, attrs),
+                    "reason": "mapped from modified code",
                     "changed_files": [changed_file],
                 })
-        if not file_matched:
+        if not modified_dep_nodes:
             warnings.append({
                 "type": "unmapped_changed_file",
-                "message": "changed file has no dep_graph node in updated RPG JSON",
+                "message": "changed file has no modified dep_graph node in updated RPG JSON",
                 "path": changed_file,
             })
 
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 324e88f..3b671b0 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -421,6 +421,7 @@ def test_attach_update_report_uses_update_rpg_result_fields(tmp_path, monkeypatc
         "_dep_to_rpg_map": {
             "scripts/a.py": ["feature_a"],
             "scripts/a.py:f": ["feature_a"],
+            "scripts/a.py:g": ["feature_a"],
         },
         "dep_graph": {
             "nodes": {
@@ -438,6 +439,14 @@ def test_attach_update_report_uses_update_rpg_result_fields(tmp_path, monkeypatc
                     "end_line": 12,
                     "rpg_nodes": ["feature_a"],
                 },
+                "scripts/a.py:g": {
+                    "type": "function",
+                    "name": "g",
+                    "path": "scripts/a.py",
+                    "start_line": 50,
+                    "end_line": 60,
+                    "rpg_nodes": ["feature_a"],
+                },
                 "tests/test_a.py": {
                     "type": "file",
                     "name": "test_a.py",
@@ -490,8 +499,8 @@ def fake_write_command_report(run):
             "renamed": [],
         },
         "git_delta": [
-            {"status": "M", "change_type": "modified", "path": "scripts/a.py", "diff": "diff --git a/scripts/a.py b/scripts/a.py\n+new"},
-            {"status": "M", "change_type": "modified", "path": "tests/test_a.py", "diff": "diff --git a/tests/test_a.py b/tests/test_a.py\n+test"},
+            {"status": "M", "change_type": "modified", "path": "scripts/a.py", "diff": "diff --git a/scripts/a.py b/scripts/a.py\n@@ -10,3 +10,4 @@\n+new"},
+            {"status": "M", "change_type": "modified", "path": "tests/test_a.py", "diff": "diff --git a/tests/test_a.py b/tests/test_a.py\n@@ -1,1 +1,2 @@\n+test"},
         ],
         "prev_ref": "prev123",
         "previous_commit": "old456",
@@ -532,24 +541,27 @@ def fake_write_command_report(run):
     assert captured["rpg_deltas"][0]["name"] == "Refresh graph visualization"
     assert {row["path"] for row in captured["dep_graph_deltas"]} >= {"scripts/a.py", "tests/test_a.py"}
     assert focused["summary"]["primary_rpg_nodes"] == 1
-    assert focused["summary"]["primary_code_nodes"] == 3
-    assert focused["summary"]["mapped_code_relations"] == 2
+    assert focused["summary"]["primary_code_nodes"] == 2
+    assert focused["summary"]["mapped_code_relations"] == 1
     assert focused["summary"]["missing_mappings"] == 1
     assert focused["warnings"] == []
     assert nodes_view["summary"]["semantic_nodes"] == 1
-    assert nodes_view["summary"]["code_nodes"] == 3
-    assert nodes_view["summary"]["mappings"] == 2
-    assert nodes_view["summary"]["edges"] == 1
+    assert nodes_view["summary"]["code_nodes"] == 2
+    assert nodes_view["summary"]["mappings"] == 1
+    assert nodes_view["summary"]["edges"] == 0
     assert nodes_view["summary"]["changed_files"] == 2
     semantic_node = nodes_view["semantic_nodes"][0]
     code_nodes = {row["node_id"]: row for row in nodes_view["code_nodes"]}
     mappings = {(row["rpg_node_id"], row["code_node_id"]): row for row in nodes_view["mappings"]}
-    edge = nodes_view["edges"][0]
+    assert set(code_nodes) == {"scripts/a.py:f", "tests/test_a.py"}
+    assert "scripts/a.py:g" not in code_nodes
+    assert "scripts/a.py" not in code_nodes
+    assert nodes_view["edges"] == []
     assert semantic_node["node_id"] == "feature_a"
     assert semantic_node["link_id"] == "rpg-feature_a"
-    assert semantic_node["mapped_code_node_ids"] == ["scripts/a.py", "scripts/a.py:f"]
-    assert semantic_node["mapped_code_link_ids"] == ["code-scripts-a.py", "code-scripts-a.py-f"]
-    assert semantic_node["mapped_code"][1]["line_range"] == {"start": 10, "end": 12}
+    assert semantic_node["mapped_code_node_ids"] == ["scripts/a.py:f"]
+    assert semantic_node["mapped_code_link_ids"] == ["code-scripts-a.py-f"]
+    assert semantic_node["mapped_code"][0]["line_range"] == {"start": 10, "end": 12}
     assert semantic_node["changed_files"] == [{"path": "scripts/a.py", "diff_anchor": "diff-scripts_a.py"}]
     assert code_nodes["scripts/a.py:f"]["line_range"] == {"start": 10, "end": 12}
     assert code_nodes["scripts/a.py:f"]["link_id"] == "code-scripts-a.py-f"
@@ -559,13 +571,9 @@ def fake_write_command_report(run):
     assert code_nodes["scripts/a.py:f"]["mapped_rpg"][0]["feature_path"] == "test_repo / Refresh graph visualization"
     assert code_nodes["tests/test_a.py"]["link_id"] == "code-tests-test_a.py"
     assert "mapped_rpg" not in code_nodes["tests/test_a.py"]
-    assert mappings[("feature_a", "scripts/a.py")]["link_id"] == "map-feature_a-scripts-a.py"
     assert mappings[("feature_a", "scripts/a.py:f")]["source_link_id"] == "rpg-feature_a"
     assert mappings[("feature_a", "scripts/a.py:f")]["target_link_id"] == "code-scripts-a.py-f"
     assert mappings[("feature_a", "scripts/a.py:f")]["changed_files"] == [{"path": "scripts/a.py", "diff_anchor": "diff-scripts_a.py"}]
-    assert edge["link_id"] == "edge-scripts-a.py-f-imports-tests-test_a.py"
-    assert edge["source_link_id"] == "code-scripts-a.py-f"
-    assert edge["target_link_id"] == "code-tests-test_a.py"
     assert nodes_view["changed_files"] == [
         {"path": "scripts/a.py", "diff_anchor": "diff-scripts_a.py"},
         {"path": "tests/test_a.py", "diff_anchor": "diff-tests_test_a.py"},
@@ -580,12 +588,12 @@ def fake_write_command_report(run):
     assert nodes_view["graph_context"]["semantic_delta"] == 3
     default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
     assert "rpg-feature_a" in default_node_link_ids
-    assert "code-scripts-a.py" in default_node_link_ids
+    assert "code-scripts-a.py" not in default_node_link_ids
     assert "code-scripts-a.py-f" in default_node_link_ids
     assert "code-tests-test_a.py" in default_node_link_ids
     assert "code-scripts-a.py-f" in nodes_view["default_focus"]["focused_code_link_ids"]
-    assert "edge-scripts-a.py-f-imports-tests-test_a.py" in nodes_view["default_focus"]["edge_link_ids"]
-    assert "code-tests-test_a.py" in nodes_view["default_focus"]["relation_endpoint_link_ids"]
+    assert nodes_view["default_focus"]["edge_link_ids"] == []
+    assert nodes_view["default_focus"]["relation_endpoint_link_ids"] == []
     assert evidence["code_deltas"][1]["file"] == "tests/test_a.py"
     assert evidence["semantic_summary"] == {"added": 0, "deleted": 0, "modified": 3, "renamed": 0}
     assert evidence["commit_range"] == {
@@ -599,6 +607,17 @@ def fake_write_command_report(run):
     assert evidence["hook_context"]["update_rpg_log"].endswith("update_rpg.log")
 
 
+def test_diff_ranges_match_only_overlapping_nodes():
+    from common.diff_ranges import changed_line_ranges_by_file, row_overlaps_changed_lines
+
+    ranges = changed_line_ranges_by_file([
+        {"file": "scripts/a.py", "diff": "diff --git a/scripts/a.py b/scripts/a.py\n@@ -10,3 +10,4 @@\n+new"}
+    ])
+
+    assert row_overlaps_changed_lines({"start_line": 10, "end_line": 12}, "scripts/a.py", ranges)
+    assert not row_overlaps_changed_lines({"start_line": 50, "end_line": 60}, "scripts/a.py", ranges)
+
+
 def test_attach_update_report_warns_on_zero_semantic_delta_without_inventing_nodes(tmp_path, monkeypatch):
     import update_graphs
 
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 8326e2d..fa3eeec 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -219,7 +219,7 @@ def fake_file_diffs_between(repo_dir, from_commit=None, to_commit="HEAD", *, fil
         assert to_commit == "abc123"
         assert files == ["a.py"]
         assert py_only is False
-        return [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
+        return [{"file": "a.py", "change_type": "modify", "diff": "diff --git a/a.py b/a.py\n@@ -10,3 +10,4 @@\n+new <unsafe>"}]
 
     monkeypatch.setattr(review, "file_diffs_between", fake_file_diffs_between)
     monkeypatch.setattr(
@@ -269,7 +269,7 @@ def fake_write_command_report(run):
         assert "locate score=1.0" in data["retrievals"][0]["hits"][0]["reason"]
         assert "impact callers=1, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
-        assert data["code_deltas"] == [{"file": "a.py", "change_type": "modify", "diff": "+new <unsafe>"}]
+        assert data["code_deltas"] == [{"file": "a.py", "change_type": "modify", "diff": "diff --git a/a.py b/a.py\n@@ -10,3 +10,4 @@\n+new <unsafe>"}]
         artifact_paths = {item["label"]: item["path"] for item in data["artifacts"]}
         assert artifact_paths["validate"] == str(validate_path)
         assert artifact_paths["locate"] == str(locate_path)
@@ -333,7 +333,7 @@ def fake_write_command_report(run):
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in focused["warnings"])
         nodes_view = focused["nodes_view"]
         assert nodes_view["summary"]["selected_feature_groups"] == 2
-        assert nodes_view["summary"]["semantic_nodes"] == 3
+        assert nodes_view["summary"]["semantic_nodes"] == 2
         semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
         assert semantic_by_id["n1"]["breadcrumb_path"] == "Node"
         assert semantic_by_id["n1"]["mapping_status"] == "mapped"
@@ -344,10 +344,7 @@ def fake_write_command_report(run):
         assert semantic_by_id["n2"]["state"] == "missing_mapping"
         assert semantic_by_id["n2"]["mapping_status"] == "missing"
         assert semantic_by_id["n2"]["selected"] is True
-        assert semantic_by_id["n3"]["breadcrumb_path"] == "Node / Context Node"
-        assert semantic_by_id["n3"]["path"] == "context.py"
-        assert semantic_by_id["n3"]["state"] == "context"
-        assert "selected" not in semantic_by_id["n3"]
+        assert "n3" not in semantic_by_id
         code = nodes_view["code_nodes"][0]
         assert code["dep_node_id"] == "a.py:f"
         assert code["path"] == "a.py"
@@ -363,8 +360,8 @@ def fake_write_command_report(run):
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
         hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
-        assert "rpg-n3" in hierarchy_text
-        assert "Node / Context Node" in hierarchy_text
+        assert "rpg-n3" not in hierarchy_text
+        assert "Node / Context Node" not in hierarchy_text
         assert '"feature_path": "context.py"' not in hierarchy_text
         default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
         assert default_node_link_ids == ["rpg-n1", "code-a.py-f"]
@@ -441,7 +438,7 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
         json.dumps({"type": "impact", "results": {"planned": {"name": "Planned Node", "dep_nodes": [dep_id], "affected_files": ["scripts/common/run_report.py"]}}}),
         encoding="utf-8",
     )
-    code_path.write_text(json.dumps({"success": True, "files_modified": ["scripts/common/run_report.py"], "last_status": "complete"}), encoding="utf-8")
+    code_path.write_text(json.dumps({"success": True, "commit_sha": "def456", "files_modified": ["scripts/common/run_report.py"], "last_status": "complete"}), encoding="utf-8")
     dep_backup_path = tmp_path / "dep_graph.before-edit-456.json"
     rpg_backup_path = tmp_path / "rpg.before-edit-456.json"
     apply_path.write_text(
@@ -492,6 +489,14 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     monkeypatch.setattr(review, "RPG_EDIT_APPLY_RESULT_FILE", apply_path)
     monkeypatch.setattr(review, "RPG_EDIT_REVIEW_RESULT_FILE", review_path)
     monkeypatch.setattr(review, "REPO_RPG_FILE", rpg_path)
+
+    def fake_file_diffs_between(repo_dir, from_commit=None, to_commit="HEAD", *, files=None, py_only=False):
+        assert to_commit == "def456"
+        assert files == ["scripts/common/run_report.py"]
+        assert py_only is False
+        return [{"file": "scripts/common/run_report.py", "change_type": "modify", "diff": "diff --git a/scripts/common/run_report.py b/scripts/common/run_report.py\n@@ -540,3 +540,4 @@\n+new"}]
+
+    monkeypatch.setattr(review, "file_diffs_between", fake_file_diffs_between)
     monkeypatch.setattr(
         review,
         "read_head",
@@ -587,7 +592,7 @@ def fake_write_command_report(run):
         assert "impact" in mapping["source"]
         nodes_view = focused["nodes_view"]
         assert nodes_view["summary"]["selected_feature_groups"] == 1
-        assert nodes_view["summary"]["semantic_nodes"] == 2
+        assert nodes_view["summary"]["semantic_nodes"] == 1
         semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
         semantic = semantic_by_id["planned"]
         assert semantic["breadcrumb_path"] == "Planned Node"
@@ -595,8 +600,7 @@ def fake_write_command_report(run):
         assert semantic["mapping_status"] == "mapped"
         assert semantic["selected"] is True
         assert semantic["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
-        assert semantic_by_id["background"]["breadcrumb_path"] == "Planned Node / Background Node"
-        assert semantic_by_id["background"]["state"] == "context"
+        assert "background" not in semantic_by_id
         code = nodes_view["code_nodes"][0]
         assert code["dep_node_id"] == dep_id
         assert code["path"] == "scripts/common/run_report.py"
@@ -609,7 +613,7 @@ def fake_write_command_report(run):
         assert any(row["type"] == "missing_reason" and row["node_id"] == "planned" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
         hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
-        assert "rpg-background" in hierarchy_text
+        assert "rpg-background" not in hierarchy_text
         assert '"feature_path": "Planned Node"' in hierarchy_text
         assert '"feature_path": "scripts/common/run_report.py"' not in hierarchy_text
         default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]

From c660e339b90be3b1983026c713b543c5cb2e9d6e Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 09:39:09 +0000
Subject: [PATCH 51/56] rpg_edit: In _render_focused_graph() at lines
 1828-1889, compute relat

---
 CoderMind/scripts/common/run_report.py      |  15 ++-
 CoderMind/scripts/rpg_edit/review.py        | 142 ++++++++++++++------
 CoderMind/scripts/update_graphs.py          |  75 ++++++-----
 CoderMind/tests/test_encode_commands.py     |  25 +++-
 CoderMind/tests/test_rpg_edit_run_report.py |  53 ++++++--
 CoderMind/tests/test_run_report.py          |  57 ++++++++
 6 files changed, 272 insertions(+), 95 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 8fc8135..6008951 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -1175,6 +1175,7 @@ def endpoint_group() -> dict[str, Any]:
 
     hierarchy_ids: set[str] = set()
     collect_hierarchy_ids(hierarchy, hierarchy_ids)
+    code_link_values = set(code_link_by_node.values())
     for edge in context_edges:
         for side in ("source", "target"):
             link_id = endpoint_link_id(edge, side)
@@ -1182,11 +1183,11 @@ def endpoint_group() -> dict[str, Any]:
                 continue
             node_id = edge.get(f"{side}_node_id")
             node_text = str(node_id or link_id)
-            is_code = node_text in code_link_by_node or link_id in set(code_link_by_node.values())
+            is_code = link_id in code_link_values
             leaf: dict[str, Any] = {
                 "id": link_id,
                 "node_id": node_text,
-                "name": edge.get("name") or edge.get("path") or node_text,
+                "name": edge.get(f"{side}_name") or edge.get("name") or edge.get(f"{side}_path") or edge.get("path") or node_text,
                 "kind": "code" if is_code else "context",
                 "state": "mapped" if is_code else "context",
                 "aliases": _ordered_texts([node_text, link_id]),
@@ -1197,9 +1198,12 @@ def endpoint_group() -> dict[str, Any]:
                     if isinstance(code, Mapping) and code.get(key) not in (None, ""):
                         leaf[key] = code.get(key)
             else:
-                for key in ("relation", "direction", "path", "reason", "source", "source_graph", "edge_source", "relation_source"):
+                for key in ("relation", "direction", "reason", "source", "source_graph", "edge_source", "relation_source"):
                     if edge.get(key) not in (None, ""):
                         leaf[key] = edge.get(key)
+                path = edge.get(f"{side}_path") or edge.get("path")
+                if path not in (None, ""):
+                    leaf["path"] = path
             endpoint_group().setdefault("children", []).append(leaf)
             hierarchy_ids.add(link_id)
 
@@ -1842,7 +1846,10 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     hidden_html = _hidden_context_html(hidden_counts if isinstance(hidden_counts, Mapping) else {})
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings") or focused_view.get("warnings")) if isinstance(warning, Mapping)]
     warnings_html = f"<details><summary>Warnings</summary>{_chain_warning_html(warnings)}</details>" if warnings else ""
-    relation_edge_total = len(_as_sequence(graph_payload.get("relation_edges") or graph_payload.get("edges") or graph_payload.get("links")))
+    relation_edges_value = graph_payload.get("relation_edges")
+    if relation_edges_value is None:
+        relation_edges_value = graph_payload.get("edges")
+    relation_edge_total = len(_as_sequence(relation_edges_value))
     graph_json = _json_for_script(graph_payload)
     d3_js = _inline_d3()
     fallback_hidden = " hidden" if d3_js else ""
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 168738f..627b9fd 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -666,12 +666,12 @@ def endpoint_leaf(edge: Dict[str, Any], side: str) -> Optional[Dict[str, Any]]:
         link_text = str(link_id or "")
         if not link_text or link_text in set(semantic_link_by_id.values()):
             return None
-        if node_text in code_by_id:
-            return make_code_leaf({"node_id": node_text, "link_id": link_text})
+        if node_text in code_by_id and link_text == code_link_by_id.get(node_text):
+            return None
         leaf: Dict[str, Any] = {
             "id": link_text,
             "node_id": node_text or link_text,
-            "name": edge.get("name") or edge.get("path") or node_text or "context",
+            "name": edge.get(f"{side}_name") or edge.get("name") or edge.get(f"{side}_path") or edge.get("path") or node_text or "context",
             "kind": "context",
             "state": edge.get("state") or "context",
             "relation": edge.get("relation"),
@@ -679,7 +679,9 @@ def endpoint_leaf(edge: Dict[str, Any], side: str) -> Optional[Dict[str, Any]]:
             "source": edge.get("source") or edge.get("source_graph") or edge.get("edge_source"),
             "aliases": _ordered_unique([node_text, link_text]),
         }
-        for key in ("path", "reason", "source_graph", "edge_source", "relation_source"):
+        path = edge.get(f"{side}_path") or edge.get("path")
+        _set_if_present(leaf, "path", path)
+        for key in ("reason", "source_graph", "edge_source", "relation_source"):
             _set_if_present(leaf, key, edge.get(key))
         return leaf
 
@@ -762,37 +764,13 @@ def endpoint_group(parent: Dict[str, Any], owner_id: str, name: str, kind: str)
         ):
             _set_if_present(leaf, key, node.get(key))
         merge_code_metadata(leaf, code_refs)
-        code_group: Optional[Dict[str, Any]] = None
-        for ref in code_refs:
-            if code_group is None:
-                code_group = endpoint_group(leaf, link_id, "Mapped code", "code_group")
-            append_endpoint(code_group, make_code_leaf(ref))
         context_group: Optional[Dict[str, Any]] = None
         for ref in relation_endpoint_refs(node_id, link_id, code_refs):
-            group_kind = "code_group" if ref.get("kind") == "code" else "context_group"
-            group_name = "Mapped code" if group_kind == "code_group" else "Relation endpoints"
-            if group_kind == "code_group":
-                if code_group is None:
-                    code_group = endpoint_group(leaf, link_id, group_name, group_kind)
-                append_endpoint(code_group, ref)
-            else:
-                if context_group is None:
-                    context_group = endpoint_group(leaf, link_id, group_name, group_kind)
-                append_endpoint(context_group, ref)
+            if context_group is None:
+                context_group = endpoint_group(leaf, link_id, "Relation endpoints", "context_group")
+            append_endpoint(context_group, ref)
         _append_hierarchy_leaf(parent, leaf)
 
-    root_code_group: Optional[Dict[str, Any]] = None
-    for code in code_nodes:
-        code_id = str(code.get("node_id") or code.get("dep_node_id") or "")
-        if not code_id:
-            continue
-        leaf = make_code_leaf({"node_id": code_id, "link_id": code.get("link_id")})
-        if str(leaf.get("id") or "") in attached_endpoint_ids:
-            continue
-        if root_code_group is None:
-            root_code_group = endpoint_group(root, "unassigned", "Additional code context", "code_group")
-        append_endpoint(root_code_group, leaf)
-
     root_context_group: Optional[Dict[str, Any]] = None
     for edge in edges:
         for side in ("source", "target"):
@@ -929,7 +907,7 @@ def owner_feature_links(edge: Dict[str, Any]) -> List[str]:
             endpoint_link_ids.append(node_id)
             if link_id in semantic_link_set:
                 continue
-            if link_id in code_links or str(node_id or "") in code_link_by_node_id:
+            if link_id in code_links:
                 continue
             context_link_ids.append(link_id)
             context_path_base = None
@@ -951,7 +929,7 @@ def owner_feature_links(edge: Dict[str, Any]) -> List[str]:
         if node.get("changed") or node.get("changed_files") or node.get("diff_anchor"):
             changed_code_links.append(link_id)
             changed_feature_links.extend(_listify(node.get("mapped_rpg_link_ids")) + code_to_feature_links.get(link_id, []))
-    node_link_ids = _ordered_unique(focused_semantic_links + changed_feature_links + changed_code_links)
+    node_link_ids = _ordered_unique(focused_semantic_links + changed_feature_links + context_link_ids)
 
     expanded_node_ids: List[Any] = ["focused-graph-root"]
     focused_path_node_ids: List[Any] = []
@@ -982,7 +960,7 @@ def focus_tree_link(link_id: Any) -> None:
     expanded_node_ids = _ordered_unique(expanded_node_ids)
     focused_path_node_ids = _ordered_unique(focused_path_node_ids)
     focused_tree_node_ids = _ordered_unique(focused_tree_node_ids)
-    focused_code_link_ids = _ordered_unique(changed_code_links + [link_id for link_id in node_link_ids if link_id in code_links])
+    focused_code_link_ids = _ordered_unique([link_id for link_id in node_link_ids if link_id in code_links])
     return {
         "node_link_ids": node_link_ids,
         "focused_node_ids": node_link_ids,
@@ -1185,12 +1163,12 @@ def _build_nodes_view(
             "link_id": _node_link_id("edge", f"{source_id}-{relation}-{target_id}"),
             "source_node_id": source_id,
             "target_node_id": target_id,
-            "source_link_id": _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
-            "target_link_id": _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
+            "source_link_id": edge.get("source_link_id") or _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
+            "target_link_id": edge.get("target_link_id") or _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
             "relation": relation,
             "state": edge.get("status") or "visible",
         }
-        for key in ("direction", "source", "source_graph", "edge_source", "relation_source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
+        for key in ("direction", "source", "source_graph", "edge_source", "relation_source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name", "source_path", "target_path", "source_name", "target_name"):
             _set_if_present(row, key, edge.get(key))
         edge_rows.append(row)
 
@@ -1524,7 +1502,7 @@ def _feature_evidence_groups(
     code_result = artifacts.get("code_result") if isinstance(artifacts.get("code_result"), dict) else {}
     apply_result = artifacts.get("apply_result") if isinstance(artifacts.get("apply_result"), dict) else {}
     impact_results = _impact_results(artifacts)
-    current_rpg_nodes, current_dep_nodes, current_rpg_edges, current_dep_edges, current_rpg_to_dep, _, graph_warnings = _current_rpg_context()
+    current_rpg_nodes, current_dep_nodes, current_rpg_edges, current_dep_edges, current_rpg_to_dep, current_dep_to_rpg, graph_warnings = _current_rpg_context()
     current_graph_available = bool(current_rpg_nodes or current_dep_nodes)
     locate_ids = {str(row.get("node_id")) for row in locate.get("results") or [] if isinstance(row, dict) and row.get("node_id")}
     applied_by_id = {
@@ -1605,9 +1583,90 @@ def add_code_node(dep_id: Any, *, source_feature: Any = None, source: str = "map
     neighbor_specs = [
         ("callers", "caller", "upstream", "total_callers"),
         ("callees", "callee", "downstream", "total_callees"),
-        ("imports", "import", "downstream", "total_imports"),
-        ("inheritance", "inheritance", "downstream", "total_inheritance"),
+        ("imports", "imports", "downstream", "total_imports"),
+        ("inheritance", "inherits", "downstream", "total_inheritance"),
     ]
+    edge_keys: set[tuple[str, str, str]] = set()
+
+    def mapped_feature_id(dep_id: Any) -> Optional[str]:
+        dep_text = str(dep_id or "")
+        if not dep_text:
+            return None
+        mapped_ids = _ordered_unique(_listify(current_dep_to_rpg.get(dep_text)) + _listify(current_dep_nodes.get(dep_text, {}).get("rpg_nodes")))
+        return str(mapped_ids[0]) if mapped_ids else None
+
+    def neighbor_id_from(item: Any, impact_key: str) -> str:
+        if isinstance(item, dict):
+            side_keys = {
+                "callers": ("source_node_id", "caller_node_id", "caller", "from", "src"),
+                "callees": ("target_node_id", "callee_node_id", "callee", "to", "dst"),
+                "imports": ("target_node_id", "import_node_id", "imported_node_id", "import", "to", "dst"),
+                "inheritance": ("target_node_id", "parent_node_id", "base_node_id", "inherits", "to", "dst"),
+            }
+            for key in side_keys.get(impact_key, ()):
+                value = item.get(key)
+                if value not in (None, ""):
+                    return str(value)
+            for key in ("rpg_node_id", "feature_node_id", "node_id", "dep_node_id", "code_node_id", "id", "path", "file"):
+                value = item.get(key)
+                if value not in (None, ""):
+                    return str(value)
+            return ""
+        if item not in (None, ""):
+            return str(item)
+        return ""
+
+    def neighbor_metadata(item: Any, neighbor_id: str) -> Dict[str, Any]:
+        if isinstance(item, dict):
+            row = dict(item)
+        else:
+            row = {}
+        dep = current_dep_nodes.get(neighbor_id, {})
+        rpg = current_rpg_nodes.get(neighbor_id, {})
+        path = row.get("path") or row.get("file") or dep.get("path") or dep.get("file") or dep.get("module") or rpg.get("path")
+        name = row.get("name") or row.get("symbol") or dep.get("name") or dep.get("symbol") or rpg.get("name") or rpg.get("symbol")
+        return {"path": path, "name": name}
+
+    def add_impact_edges(node_id: str, impact: Dict[str, Any], focus_reason: str) -> None:
+        for impact_key, relation, direction, _total_key in neighbor_specs:
+            for item in _listify(impact.get(impact_key)):
+                raw_neighbor_id = neighbor_id_from(item, impact_key)
+                if not raw_neighbor_id:
+                    continue
+                neighbor_id = mapped_feature_id(raw_neighbor_id) or raw_neighbor_id
+                if neighbor_id == node_id:
+                    continue
+                if impact_key == "callers":
+                    source_id, target_id = neighbor_id, node_id
+                else:
+                    source_id, target_id = node_id, neighbor_id
+                key = (str(source_id), str(target_id), relation)
+                if key in edge_keys:
+                    continue
+                edge_keys.add(key)
+                metadata = neighbor_metadata(item, raw_neighbor_id)
+                edge_row: Dict[str, Any] = {
+                    "source_node_id": source_id,
+                    "target_node_id": target_id,
+                    "relation": relation,
+                    "direction": direction,
+                    "source": "impact",
+                    "source_graph": "impact",
+                    "edge_source": "impact",
+                    "relation_source": impact_key,
+                    "rpg_node_id": node_id,
+                    "neighbor_node_id": neighbor_id,
+                    "reason": focus_reason or f"impact {impact_key}",
+                }
+                if neighbor_id not in current_rpg_nodes:
+                    side = "source" if impact_key == "callers" else "target"
+                    edge_row[f"{side}_link_id"] = _node_link_id("context", raw_neighbor_id)
+                _set_if_present(edge_row, "path", metadata.get("path"))
+                _set_if_present(edge_row, "name", metadata.get("name"))
+                side = "source" if impact_key == "callers" else "target"
+                _set_if_present(edge_row, f"{side}_path", metadata.get("path"))
+                _set_if_present(edge_row, f"{side}_name", metadata.get("name"))
+                all_edges.append(edge_row)
 
     for candidate in candidates:
         raw_node_id = candidate.get("node_id")
@@ -1648,10 +1707,11 @@ def add_code_node(dep_id: Any, *, source_feature: Any = None, source: str = "map
         for impact_key, _relation, _direction, total_key in neighbor_specs:
             items = _listify(impact.get(impact_key))
             total = count_value(impact_summary.get(total_key), len(items))
-            hidden = max(0, total)
+            hidden = max(0, total - len(items))
             if hidden:
                 node_hidden_counts[impact_key] = hidden
                 impact_hidden_counts[impact_key] = impact_hidden_counts.get(impact_key, 0) + hidden
+        add_impact_edges(node_id, impact, focus_reason)
 
         apply_row = applied_by_id.get(node_id, {})
         rpg_row: Dict[str, Any] = dict(current_node) if current_node else {"node_id": node_id, "link_id": _node_link_id("rpg", node_id)}
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index 4d630a3..d1c07b6 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -608,29 +608,10 @@ def append_endpoint(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
             "mapped_code_count",
         ):
             _set_if_present(leaf, key, node.get(key))
-        code_group: Optional[dict[str, Any]] = None
-        for ref in _listify(node.get("mapped_code")):
-            if not isinstance(ref, dict):
-                continue
-            if code_group is None:
-                code_group = endpoint_group(leaf, link_id, "Mapped code", "code_group")
-            append_endpoint(code_group, make_code_leaf(ref))
         _append_hierarchy_leaf(parent, leaf)
 
-    root_code_group: Optional[dict[str, Any]] = None
-    for code in code_nodes:
-        code_id = str(code.get("node_id") or code.get("dep_node_id") or "")
-        if not code_id:
-            continue
-        leaf = make_code_leaf({"node_id": code_id, "link_id": code.get("link_id")})
-        if str(leaf.get("id") or "") in attached_endpoint_ids:
-            continue
-        if root_code_group is None:
-            root_code_group = endpoint_group(root, "unassigned", "Additional code context", "code_group")
-        append_endpoint(root_code_group, leaf)
-
     root_context_group: Optional[dict[str, Any]] = None
-    known_links = {str(node.get("link_id") or "") for node in semantic_nodes + code_nodes}
+    known_links = {str(node.get("link_id") or "") for node in semantic_nodes}
     for edge in edges:
         for side in ("source", "target"):
             link_id = str(edge.get(f"{side}_link_id") or "")
@@ -640,14 +621,16 @@ def append_endpoint(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
             leaf = {
                 "id": link_id,
                 "node_id": node_id,
-                "name": edge.get("name") or edge.get("path") or node_id or "context",
+                "name": edge.get(f"{side}_name") or edge.get("name") or edge.get(f"{side}_path") or edge.get("path") or node_id or "context",
                 "kind": "context",
                 "state": "context",
                 "relation": edge.get("relation"),
                 "source": edge.get("source") or edge.get("source_graph") or edge.get("edge_source"),
                 "aliases": _ordered_unique_text([node_id, link_id]),
             }
-            for key in ("path", "reason", "source_graph", "edge_source", "relation_source"):
+            path = edge.get(f"{side}_path") or edge.get("path")
+            _set_if_present(leaf, "path", path)
+            for key in ("reason", "source_graph", "edge_source", "relation_source"):
                 _set_if_present(leaf, key, edge.get(key))
             if root_context_group is None:
                 root_context_group = endpoint_group(root, "unassigned", "Additional relation endpoints", "context_group")
@@ -746,7 +729,7 @@ def remember_path(alias: Any, path_ids: list[str]) -> None:
                 continue
             endpoint_link_ids.append(link_id)
             endpoint_link_ids.append(node_id)
-            if link_id in semantic_link_set or link_id in code_link_set or str(node_id or "") in code_link_by_node_id:
+            if link_id in semantic_link_set or link_id in code_link_set:
                 continue
             context_link_ids.append(link_id)
             context_path = ["focused-graph-root", _node_link_id("context_group", "unassigned"), link_id]
@@ -760,7 +743,7 @@ def remember_path(alias: Any, path_ids: list[str]) -> None:
         if node.get("changed") or node.get("changed_files") or node.get("diff_anchor"):
             changed_code_links.append(link_id)
             changed_feature_links.extend(_listify(node.get("mapped_rpg_link_ids")) + code_to_feature_links.get(link_id, []))
-    node_link_ids = _ordered_unique_text(focused_semantic_links + changed_feature_links + changed_code_links)
+    node_link_ids = _ordered_unique_text(focused_semantic_links + changed_feature_links + context_link_ids)
 
     expanded_node_ids: list[Any] = ["focused-graph-root"]
     focused_path_node_ids: list[Any] = []
@@ -777,7 +760,7 @@ def remember_path(alias: Any, path_ids: list[str]) -> None:
         "node_link_ids": node_link_ids,
         "focused_node_ids": node_link_ids,
         "focused_tree_node_ids": _ordered_unique_text(focused_tree_node_ids),
-        "focused_code_link_ids": _ordered_unique_text(changed_code_links + [link_id for link_id in node_link_ids if link_id in code_link_set]),
+        "focused_code_link_ids": _ordered_unique_text([link_id for link_id in node_link_ids if link_id in code_link_set]),
         "expanded_node_ids": _ordered_unique_text(expanded_node_ids),
         "default_expanded_node_ids": _ordered_unique_text(expanded_node_ids),
         "focused_path_node_ids": _ordered_unique_text(focused_path_node_ids),
@@ -968,12 +951,12 @@ def _build_nodes_view(
             "link_id": _node_link_id("edge", f"{source_id}-{relation}-{target_id}"),
             "source_node_id": source_id,
             "target_node_id": target_id,
-            "source_link_id": _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
-            "target_link_id": _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
+            "source_link_id": edge.get("source_link_id") or _edge_endpoint_link_id(source_id, rpg_by_id, code_by_id),
+            "target_link_id": edge.get("target_link_id") or _edge_endpoint_link_id(target_id, rpg_by_id, code_by_id),
             "relation": relation,
             "state": edge.get("status") or "visible",
         }
-        for key in ("direction", "source", "source_graph", "edge_source", "relation_source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name"):
+        for key in ("direction", "source", "source_graph", "edge_source", "relation_source", "path", "reason", "rpg_node_id", "neighbor_node_id", "name", "source_path", "target_path", "source_name", "target_name"):
             _set_if_present(row, key, edge.get(key))
         edge_rows.append(row)
 
@@ -1061,25 +1044,29 @@ def _edge_rows(dep_edges: Any, code_ids: set[str]) -> list[dict[str, Any]]:
     if not isinstance(dep_edges, list):
         return rows
     changed_states = {"added", "changed", "deleted", "modified", "renamed"}
+    containment_relations = {"contains", "containment", "composes"}
     for edge in dep_edges:
         if not isinstance(edge, dict):
             continue
         attrs = edge.get("attrs") if isinstance(edge.get("attrs"), dict) else {}
-        change = str(edge.get("change") or edge.get("change_type") or edge.get("status") or attrs.get("change") or attrs.get("change_type") or "").lower()
-        if change not in changed_states:
+        relation = edge.get("relation") or edge.get("type") or attrs.get("relation") or attrs.get("type") or "dependency"
+        if str(relation).lower() in containment_relations:
             continue
         source = edge.get("src") or edge.get("source") or edge.get("from")
         target = edge.get("dst") or edge.get("target") or edge.get("to")
-        if source not in code_ids or target not in code_ids:
+        if source not in code_ids and target not in code_ids:
+            continue
+        change = str(edge.get("change") or edge.get("change_type") or edge.get("status") or attrs.get("change") or attrs.get("change_type") or "").lower()
+        if change and change not in changed_states:
             continue
         rows.append({
             "source_node_id": source,
             "target_node_id": target,
-            "relation": edge.get("relation") or edge.get("type") or attrs.get("type") or "dependency",
+            "relation": relation,
             "source_graph": "dep_graph",
             "edge_source": "dep_graph",
-            "reason": "edge changed",
-            "status": change,
+            "reason": "edge incident to modified dep node" if not change else "edge changed",
+            "status": change or "affected",
         })
     return rows[:50]
 
@@ -1137,8 +1124,26 @@ def _build_update_focus(result: dict, code_deltas: list[dict[str, Any]], semanti
                 "path": changed_file,
             })
 
+    dep_edge_rows = _edge_rows(dep_graph.get("edges") if isinstance(dep_graph, dict) else [], matched_dep_ids)
+    for edge in dep_edge_rows:
+        for side in ("source", "target"):
+            dep_id = str(edge.get(f"{side}_node_id") or "")
+            dep_attrs = dep_graph.get("nodes", {}).get(dep_id, {}) if isinstance(dep_graph.get("nodes"), dict) else {}
+            mapped_rpg_ids = _ordered_unique_text(_listify(edge.get(f"{side}_rpg_nodes")) + _listify(dep_attrs.get("rpg_nodes")) + _listify(dep_to_rpg.get(dep_id)))
+            if mapped_rpg_ids:
+                rpg_id = mapped_rpg_ids[0]
+                node = rpg_nodes.get(rpg_id)
+                if isinstance(node, dict):
+                    semantic_by_id.setdefault(rpg_id, _rpg_node_row(rpg_id, node, rpg_paths, _listify(dep_attrs.get("path"))))
+                edge[f"{side}_node_id"] = rpg_id
+                edge[f"{side}_link_id"] = _node_link_id("rpg", rpg_id)
+                continue
+            if dep_id in matched_dep_ids:
+                edge[f"{side}_link_id"] = _node_link_id("context", dep_id)
+            _set_if_present(edge, f"{side}_path", _dep_node_path(dep_id, dep_attrs))
+            _set_if_present(edge, f"{side}_name", dep_attrs.get("name") or dep_attrs.get("symbol"))
     semantic_nodes = list(semantic_by_id.values())
-    dep_edges = _edge_rows(dep_graph.get("edges") if isinstance(dep_graph, dict) else [], matched_dep_ids)
+    dep_edges = dep_edge_rows
     unmatched_files = set(changed_files)
     for node in code_nodes:
         unmatched_files.difference_update(str(path) for path in _listify(node.get("changed_files")))
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 3b671b0..795c574 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -548,7 +548,7 @@ def fake_write_command_report(run):
     assert nodes_view["summary"]["semantic_nodes"] == 1
     assert nodes_view["summary"]["code_nodes"] == 2
     assert nodes_view["summary"]["mappings"] == 1
-    assert nodes_view["summary"]["edges"] == 0
+    assert nodes_view["summary"]["edges"] == 1
     assert nodes_view["summary"]["changed_files"] == 2
     semantic_node = nodes_view["semantic_nodes"][0]
     code_nodes = {row["node_id"]: row for row in nodes_view["code_nodes"]}
@@ -556,7 +556,14 @@ def fake_write_command_report(run):
     assert set(code_nodes) == {"scripts/a.py:f", "tests/test_a.py"}
     assert "scripts/a.py:g" not in code_nodes
     assert "scripts/a.py" not in code_nodes
-    assert nodes_view["edges"] == []
+    assert len(nodes_view["edges"]) == 1
+    edge = nodes_view["edges"][0]
+    assert edge["source_node_id"] == "feature_a"
+    assert edge["target_node_id"] == "tests/test_a.py"
+    assert edge["source_link_id"] == "rpg-feature_a"
+    assert edge["target_link_id"] == "context-tests-test_a.py"
+    assert edge["relation"] == "imports"
+    assert edge["source_graph"] == "dep_graph"
     assert semantic_node["node_id"] == "feature_a"
     assert semantic_node["link_id"] == "rpg-feature_a"
     assert semantic_node["mapped_code_node_ids"] == ["scripts/a.py:f"]
@@ -580,6 +587,9 @@ def fake_write_command_report(run):
     ]
     assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
     assert nodes_view["hierarchy"]["children"][0]["id"] == "feature-path-test_repo"
+    hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
+    assert "Mapped code" not in hierarchy_text
+    assert "Additional code context" not in hierarchy_text
     assert nodes_view["focused_graph"]["schema"] == "cmind.focused_graph.v1"
     assert nodes_view["focused_graph"]["hierarchy"] == nodes_view["hierarchy"]
     assert nodes_view["focused_graph"]["default_focus"] == nodes_view["default_focus"]
@@ -588,12 +598,13 @@ def fake_write_command_report(run):
     assert nodes_view["graph_context"]["semantic_delta"] == 3
     default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
     assert "rpg-feature_a" in default_node_link_ids
+    assert "context-tests-test_a.py" in default_node_link_ids
     assert "code-scripts-a.py" not in default_node_link_ids
-    assert "code-scripts-a.py-f" in default_node_link_ids
-    assert "code-tests-test_a.py" in default_node_link_ids
-    assert "code-scripts-a.py-f" in nodes_view["default_focus"]["focused_code_link_ids"]
-    assert nodes_view["default_focus"]["edge_link_ids"] == []
-    assert nodes_view["default_focus"]["relation_endpoint_link_ids"] == []
+    assert "code-scripts-a.py-f" not in default_node_link_ids
+    assert "code-tests-test_a.py" not in default_node_link_ids
+    assert nodes_view["default_focus"]["focused_code_link_ids"] == []
+    assert nodes_view["default_focus"]["edge_link_ids"] == ["edge-feature_a-imports-tests-test_a.py"]
+    assert "context-tests-test_a.py" in nodes_view["default_focus"]["relation_endpoint_link_ids"]
     assert evidence["code_deltas"][1]["file"] == "tests/test_a.py"
     assert evidence["semantic_summary"] == {"added": 0, "deleted": 0, "modified": 3, "renamed": 0}
     assert evidence["commit_range"] == {
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index fa3eeec..08c8852 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -150,7 +150,9 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
                     "name": "Node",
                     "dep_nodes": ["a.py:f"],
                     "affected_files": ["a.py"],
-                    "impact_summary": {"total_callers": 1, "affected_file_count": 1},
+                    "callers": [{"node_id": "tests/test_a.py:test_f", "name": "test_f", "path": "tests/test_a.py"}],
+                    "callees": [{"node_id": "helpers.py:g", "name": "g", "path": "helpers.py"}],
+                    "impact_summary": {"total_callers": 1, "total_callees": 1, "affected_file_count": 1},
                 },
                 "n2": {
                     "name": "Missing Node",
@@ -322,7 +324,6 @@ def fake_write_command_report(run):
         assert focused["primary_rpg_nodes"][0]["node_id"] == "n1"
         assert focused["primary_rpg_nodes"][0]["mapping_status"] == "mapped"
         assert focused["primary_rpg_nodes"][0]["changed_files"] == ["a.py"]
-        assert focused["primary_rpg_nodes"][0]["hidden_counts"]["callers"] == 1
         assert focused["primary_code_nodes"][0]["node_id"] == "a.py:f"
         assert focused["primary_code_nodes"][0]["path"] == "a.py"
         mapping_statuses = {row["status"] for row in focused["mappings"]}
@@ -339,7 +340,6 @@ def fake_write_command_report(run):
         assert semantic_by_id["n1"]["mapping_status"] == "mapped"
         assert semantic_by_id["n1"]["selected"] is True
         assert semantic_by_id["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
-        assert semantic_by_id["n1"]["hidden_counts"]["callers"] == 1
         assert semantic_by_id["n2"]["breadcrumb_path"] == "Node / Missing Node"
         assert semantic_by_id["n2"]["state"] == "missing_mapping"
         assert semantic_by_id["n2"]["mapping_status"] == "missing"
@@ -356,15 +356,27 @@ def fake_write_command_report(run):
         assert bridge_by_rpg["n1"]["status"] == "mapped"
         assert bridge_by_rpg["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
         assert bridge_by_rpg["n2"]["state"] == "missing_mapping"
-        assert nodes_view["hidden_counts"]["callers"] == 1
+        assert nodes_view["hidden_counts"] == {}
+        assert nodes_view["summary"]["edges"] == 2
+        assert focused["summary"]["edges"] == 2
+        edges_by_relation = {row["relation"]: row for row in nodes_view["edges"]}
+        assert edges_by_relation["caller"]["source_node_id"] == "tests/test_a.py:test_f"
+        assert edges_by_relation["caller"]["target_node_id"] == "n1"
+        assert edges_by_relation["caller"]["source_link_id"] == "context-tests-test_a.py-test_f"
+        assert edges_by_relation["callee"]["source_node_id"] == "n1"
+        assert edges_by_relation["callee"]["target_node_id"] == "helpers.py:g"
+        assert edges_by_relation["callee"]["target_link_id"] == "context-helpers.py-g"
         assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
         hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
         assert "rpg-n3" not in hierarchy_text
         assert "Node / Context Node" not in hierarchy_text
         assert '"feature_path": "context.py"' not in hierarchy_text
+        assert "Mapped code" not in hierarchy_text
+        assert "Additional code context" not in hierarchy_text
         default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
-        assert default_node_link_ids == ["rpg-n1", "code-a.py-f"]
+        assert default_node_link_ids == ["rpg-n1", "context-tests-test_a.py-test_f", "context-helpers.py-g"]
+        assert "code-a.py-f" not in default_node_link_ids
         assert "rpg-n2" not in default_node_link_ids
         assert "rpg-n3" not in default_node_link_ids
         focused_tree_node_ids = nodes_view["default_focus"]["focused_tree_node_ids"]
@@ -435,7 +447,18 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
     locate_path.write_text(json.dumps({"type": "candidates", "results": [{"node_id": "other", "name": "Other"}]}), encoding="utf-8")
     plan_path.write_text(json.dumps({"affected_nodes": ["planned"], "code_changes": [{"file_path": "scripts/common/run_report.py"}]}), encoding="utf-8")
     impact_path.write_text(
-        json.dumps({"type": "impact", "results": {"planned": {"name": "Planned Node", "dep_nodes": [dep_id], "affected_files": ["scripts/common/run_report.py"]}}}),
+        json.dumps({
+            "type": "impact",
+            "results": {
+                "planned": {
+                    "name": "Planned Node",
+                    "dep_nodes": [dep_id],
+                    "affected_files": ["scripts/common/run_report.py"],
+                    "callers": [{"node_id": "tests/test_report.py:test_render_artifacts", "name": "test_render_artifacts", "path": "tests/test_report.py"}],
+                    "impact_summary": {"total_callers": 1},
+                }
+            },
+        }),
         encoding="utf-8",
     )
     code_path.write_text(json.dumps({"success": True, "commit_sha": "def456", "files_modified": ["scripts/common/run_report.py"], "last_status": "complete"}), encoding="utf-8")
@@ -474,7 +497,10 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
             },
             "edges": [],
             "dep_graph": {
-                "nodes": {dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "line_start": 537, "line_end": 564, "rpg_nodes": ["planned"]}},
+                "nodes": {
+                    dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "line_start": 537, "line_end": 564, "rpg_nodes": ["planned"]},
+                    "tests/test_report.py:test_render_artifacts": {"name": "test_render_artifacts", "type": "function", "module": "tests/test_report.py", "line_start": 20, "line_end": 40},
+                },
                 "edges": [],
             },
             "_dep_to_rpg_map": {dep_id: ["planned"]},
@@ -610,14 +636,25 @@ def fake_write_command_report(run):
         bridge = nodes_view["mappings"][0]
         assert bridge["status"] == "mapped"
         assert bridge["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
+        assert nodes_view["summary"]["edges"] == 1
+        assert focused["summary"]["edges"] == 1
+        edge = nodes_view["edges"][0]
+        assert edge["relation"] == "caller"
+        assert edge["source_node_id"] == "tests/test_report.py:test_render_artifacts"
+        assert edge["target_node_id"] == "planned"
+        assert edge["source_link_id"] == "context-tests-test_report.py-test_render_artifacts"
+        assert edge["target_link_id"] == "rpg-planned"
         assert any(row["type"] == "missing_reason" and row["node_id"] == "planned" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
         hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
         assert "rpg-background" not in hierarchy_text
         assert '"feature_path": "Planned Node"' in hierarchy_text
         assert '"feature_path": "scripts/common/run_report.py"' not in hierarchy_text
+        assert "Mapped code" not in hierarchy_text
+        assert "Additional code context" not in hierarchy_text
         default_node_link_ids = nodes_view["default_focus"]["node_link_ids"]
-        assert default_node_link_ids == ["rpg-planned", "code-scripts-common-run_report.py-_render_artifacts"]
+        assert default_node_link_ids == ["rpg-planned", "context-tests-test_report.py-test_render_artifacts"]
+        assert "code-scripts-common-run_report.py-_render_artifacts" not in default_node_link_ids
         assert "rpg-background" not in default_node_link_ids
         assert "rpg-background" not in nodes_view["default_focus"]["focused_tree_node_ids"]
         assert nodes_view["default_focus"]["edge_depth"] == 1
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 84470e4..8245d7c 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -585,6 +585,63 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "Inspector metadata" not in html
 
 
+def test_common_run_report_write_command_report_counts_explicit_empty_relation_edges(tmp_path: Path) -> None:
+    report = write_command_report(
+        {
+            "command": "test",
+            "title": "Test",
+            "status": "ok",
+            "summary": [],
+            "steps": [],
+            "focused_view": {
+                "summary": {"semantic_nodes": 2, "edges": 0},
+                "nodes_view": {
+                    "summary": {"semantic_nodes": 2, "edges": 0},
+                    "semantic_nodes": [
+                        {"node_id": "n1", "link_id": "rpg-n1", "name": "Node 1"},
+                        {"node_id": "n2", "link_id": "rpg-n2", "name": "Node 2"},
+                    ],
+                    "code_nodes": [],
+                    "mappings": [],
+                    "edges": [],
+                    "hierarchy": {
+                        "id": "focused-graph-root",
+                        "name": "Focused graph",
+                        "kind": "root",
+                        "children": [
+                            {"id": "rpg-n1", "name": "Node 1", "kind": "feature"},
+                            {"id": "rpg-n2", "name": "Node 2", "kind": "feature"},
+                        ],
+                    },
+                    "default_focus": {"node_link_ids": ["rpg-n1"], "show_edges": True},
+                    "focused_graph": {
+                        "schema": "cmind.focused_graph.v1",
+                        "hierarchy": {
+                            "id": "focused-graph-root",
+                            "name": "Focused graph",
+                            "kind": "root",
+                            "children": [
+                                {"id": "rpg-n1", "name": "Node 1", "kind": "feature"},
+                                {"id": "rpg-n2", "name": "Node 2", "kind": "feature"},
+                            ],
+                        },
+                        "default_focus": {"node_link_ids": ["rpg-n1"], "show_edges": True},
+                    },
+                },
+            },
+        },
+        report_dir=tmp_path,
+    )
+
+    html = report.read_text(encoding="utf-8")
+    assert "Visible relation edges: 0/0" in html
+    assert "Visible relation edges: 0/2" not in html
+    graph_json = html.split("data-focused-graph-json>", 1)[1].split("</script>", 1)[0]
+    graph_payload = json.loads(html_lib.unescape(graph_json))
+    assert graph_payload["relation_edges"] == []
+    assert len(graph_payload["links"]) == 2
+
+
 def test_common_run_report_write_command_report_renders_static_fallback_without_d3(tmp_path: Path, monkeypatch) -> None:
     monkeypatch.setattr(run_report, "_D3_ASSET", tmp_path / "missing-d3.v7.min.js")
 

From 04c6e337af0f7d14cf577eb2375b59a6b7653fb9 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 09:50:33 +0000
Subject: [PATCH 52/56] review: fix issues found in impact review

Align the rpg_edit report fixture assertions with the impact caller data now used to populate focused_view edges.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/tests/test_rpg_edit_run_report.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 08c8852..7d8fced 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -562,7 +562,7 @@ def fake_write_command_report(run):
         assert data["retrievals"][0]["hits"][0]["locate_state"] == "missing"
         assert data["retrievals"][0]["hits"][0]["mapping_state"] == "mapped"
         assert "1 mapped code relations" in data["retrievals"][0]["hits"][0]["reason"]
-        assert "impact callers=0, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
+        assert "impact callers=1, affected_files=1" in data["retrievals"][0]["hits"][0]["reason"]
         assert data["retrievals"][1]["tool"] == str(impact_path)
         artifact_paths = {item["label"]: item["path"] for item in data["artifacts"]}
         assert artifact_paths["validate"] == str(validate_path)
@@ -663,7 +663,7 @@ def fake_write_command_report(run):
         assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
         assert nodes_view["graph_context"]["current_graph_available"] is True
         assert nodes_view["graph_context"]["current_rpg_nodes"] == 2
-        assert nodes_view["graph_context"]["current_dep_nodes"] == 1
+        assert nodes_view["graph_context"]["current_dep_nodes"] == 2
         assert focused["apply"]["status"] == "dep_refreshed"
         return report_path
 

From cb52965f7c61296461ecb3d9c8f2509a45bd67fd Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 10:45:31 +0000
Subject: [PATCH 53/56] rpg_edit: In _feature_evidence_groups() lines
 1494-1846, derive visibl

---
 CoderMind/scripts/common/run_report.py      | 35 +++++++-
 CoderMind/scripts/rpg_edit/review.py        | 60 ++++++++++++--
 CoderMind/tests/test_rpg_edit_run_report.py | 88 ++++++++++++++-------
 CoderMind/tests/test_run_report.py          | 27 +++++++
 4 files changed, 173 insertions(+), 37 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index 6008951..a17be4e 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -221,6 +221,10 @@ def _normalize_focused_view(value: Any) -> dict[str, Any]:
         for edge in _as_sequence(value.get("edges"))
     ]
     normalized["hidden_counts"] = dict(value.get("hidden_counts") or {}) if isinstance(value.get("hidden_counts"), Mapping) else {}
+    normalized["hidden_context_nodes"] = [
+        dict(node) if isinstance(node, Mapping) else {"detail": node}
+        for node in _as_sequence(value.get("hidden_context_nodes"))
+    ]
     normalized["warnings"] = [
         dict(warning) if isinstance(warning, Mapping) else {"message": warning}
         for warning in _as_sequence(value.get("warnings"))
@@ -238,7 +242,7 @@ def _normalize_focused_view(value: Any) -> dict[str, Any]:
 def _normalize_nodes_view(value: Mapping[str, Any]) -> dict[str, Any]:
     normalized = dict(value)
     normalized["summary"] = dict(value.get("summary") or {}) if isinstance(value.get("summary"), Mapping) else {}
-    for key in ("semantic_nodes", "code_nodes", "mappings", "edges", "warnings", "changed_files"):
+    for key in ("semantic_nodes", "code_nodes", "mappings", "edges", "warnings", "changed_files", "hidden_context_nodes"):
         normalized[key] = [
             dict(item) if isinstance(item, Mapping) else {"detail": item}
             for item in _as_sequence(value.get(key))
@@ -718,10 +722,27 @@ def _combined_hidden_counts(hidden_counts: Mapping[str, Any]) -> list[tuple[str,
     return rows
 
 
-def _hidden_context_html(hidden_counts: Mapping[str, Any]) -> str:
+def _hidden_context_html(hidden_counts: Mapping[str, Any], hidden_context_nodes: Sequence[Any] = ()) -> str:
     parts = []
     for relation, count in _combined_hidden_counts(hidden_counts):
         parts.append(f"<p class=\"reason\">Hidden {_h(count)} additional {_h(relation)} neighbors.</p>")
+    rows = [node for node in _as_sequence(hidden_context_nodes) if isinstance(node, Mapping)]
+    if rows:
+        items = []
+        for node in rows:
+            node_id = node.get("node_id") or node.get("rpg_node_id") or node.get("id") or "hidden context"
+            title = node.get("name") or node.get("symbol") or node_id
+            reason = node.get("hidden_reason") or node.get("reason") or "hidden context"
+            path = node.get("breadcrumb_path") or node.get("feature_path") or node.get("path") or ""
+            items.append(
+                "<li>"
+                f"<code>{_h(node_id)}</code> {_h(title)}"
+                f" <span class=\"badge\">hidden context</span>"
+                f"<div class=\"reason\">{_h(reason)}</div>"
+                f"<div class=\"reason\">{_h(path)}</div>"
+                "</li>"
+            )
+        parts.append("<details><summary>Hidden context nodes</summary><ul class=\"hit-list\">" + "".join(items) + "</ul></details>")
     return "".join(parts)
 
 
@@ -1087,6 +1108,7 @@ def _focused_graph_payload(focused_view: Mapping[str, Any], file_anchors: Mappin
     mappings = [mapping for mapping in _as_sequence(nodes_view.get("mappings")) if isinstance(mapping, Mapping)]
     context_edges = [edge for edge in _as_sequence(nodes_view.get("edges")) if isinstance(edge, Mapping)]
     hidden_counts = nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else focused_view.get("hidden_counts", {})
+    hidden_context_nodes = [node for node in _as_sequence(nodes_view.get("hidden_context_nodes") or focused_view.get("hidden_context_nodes")) if isinstance(node, Mapping)]
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings")) if isinstance(warning, Mapping)]
     focused_graph = nodes_view.get("focused_graph") if isinstance(nodes_view.get("focused_graph"), Mapping) else {}
     hierarchy = nodes_view.get("hierarchy") or focused_graph.get("hierarchy") or {}
@@ -1342,6 +1364,7 @@ def candidates(edge: Mapping[str, Any], side: str) -> list[str]:
         "mappings": mappings,
         "edges": context_edges,
         "hidden_counts": hidden_counts,
+        "hidden_context_nodes": hidden_context_nodes,
         "warnings": warnings,
         "hierarchy": hierarchy,
         "default_focus": default_focus,
@@ -1843,7 +1866,8 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
         ("Warnings", "warnings", len(_as_sequence(nodes_view.get("warnings")))),
     ])
     hidden_counts = nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else focused_view.get("hidden_counts", {})
-    hidden_html = _hidden_context_html(hidden_counts if isinstance(hidden_counts, Mapping) else {})
+    hidden_context_nodes = [node for node in _as_sequence(nodes_view.get("hidden_context_nodes") or focused_view.get("hidden_context_nodes")) if isinstance(node, Mapping)]
+    hidden_html = _hidden_context_html(hidden_counts if isinstance(hidden_counts, Mapping) else {}, hidden_context_nodes)
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings") or focused_view.get("warnings")) if isinstance(warning, Mapping)]
     warnings_html = f"<details><summary>Warnings</summary>{_chain_warning_html(warnings)}</details>" if warnings else ""
     relation_edges_value = graph_payload.get("relation_edges")
@@ -1923,7 +1947,10 @@ def _legacy_render_focused_nodes_map(focused_view: dict[str, Any], file_anchors:
         for mapping in _as_sequence(nodes_view.get("mappings"))
         if isinstance(mapping, Mapping)
     ]
-    hidden_html = _hidden_context_html(nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else {})
+    hidden_html = _hidden_context_html(
+        nodes_view.get("hidden_counts") if isinstance(nodes_view.get("hidden_counts"), Mapping) else {},
+        _as_sequence(nodes_view.get("hidden_context_nodes")),
+    )
     warnings = [warning for warning in _as_sequence(nodes_view.get("warnings")) if isinstance(warning, Mapping)]
     warnings_html = f"<h3>Warnings</h3>{_chain_warning_html(warnings)}" if warnings else ""
     body = summary_html
diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 627b9fd..30a6acd 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -1208,6 +1208,7 @@ def _build_nodes_view(
 
 _LEGACY_FOCUSED_VIEW_CAPS = {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
 _FOCUSED_WARNING_TYPES = {"missing_mapping", "missing_reason", "stale_graph"}
+_HIDDEN_CONTEXT_REASON = "selected by plan/impact, hidden because no modified mapped code"
 
 
 def _set_if_present(row: Dict[str, Any], key: str, value: Any) -> None:
@@ -1771,10 +1772,54 @@ def add_impact_edges(node_id: str, impact: Dict[str, Any], focus_reason: str) ->
                 mapping_row["changed_files"] = changed_for_node
             mapping_rows_all.append(mapping_row)
 
-    primary_rpg_nodes = primary_rpg_nodes_all
+    selected_rpg_ids_all = {str(row.get("node_id") or "") for row in primary_rpg_nodes_all if row.get("node_id") not in (None, "")}
+    modified_mapped_rpg_ids = _ordered_unique([row.get("rpg_node_id") for row in mapping_rows_all if row.get("code_node_id")])
+    edge_endpoint_rpg_ids = _ordered_unique([
+        endpoint
+        for edge in all_edges
+        for endpoint in (edge.get("source_node_id"), edge.get("target_node_id"))
+        if str(endpoint or "") in current_rpg_nodes or str(endpoint or "") in selected_rpg_ids_all
+    ])
+    visible_rpg_ids = _ordered_unique(modified_mapped_rpg_ids + edge_endpoint_rpg_ids)
+    visible_rpg_id_set = set(visible_rpg_ids)
+    primary_rpg_by_id = {
+        str(row.get("node_id")): row
+        for row in primary_rpg_nodes_all
+        if row.get("node_id") not in (None, "")
+    }
+    primary_rpg_nodes: List[Dict[str, Any]] = []
+    for node_id in visible_rpg_ids:
+        row = primary_rpg_by_id.get(node_id)
+        if row is None and node_id in current_rpg_nodes:
+            row = dict(current_rpg_nodes[node_id])
+            row["node_id"] = node_id
+            row.setdefault("link_id", _node_link_id("rpg", node_id))
+            row.setdefault("status", "context")
+            row.setdefault("graph_state", "available")
+        if row is not None:
+            primary_rpg_nodes.append(row)
+    visible_primary_rpg_ids = {str(row.get("node_id") or "") for row in primary_rpg_nodes}
+    hidden_context_nodes: List[Dict[str, Any]] = []
+    for row in primary_rpg_nodes_all:
+        node_id = str(row.get("node_id") or "")
+        if not node_id or node_id in visible_primary_rpg_ids:
+            continue
+        hidden_row = dict(row)
+        hidden_row["hidden_reason"] = _HIDDEN_CONTEXT_REASON
+        hidden_row["reason"] = _HIDDEN_CONTEXT_REASON
+        hidden_context_nodes.append(hidden_row)
     primary_code_nodes_all = list(code_node_by_id.values())
-    primary_code_nodes = primary_code_nodes_all
-    mappings = mapping_rows_all
+    visible_code_ids = {
+        str(row.get("code_node_id") or row.get("dep_node_id") or "")
+        for row in mapping_rows_all
+        if str(row.get("rpg_node_id") or "") in visible_primary_rpg_ids and (row.get("code_node_id") or row.get("dep_node_id")) not in (None, "")
+    }
+    primary_code_nodes = [row for row in primary_code_nodes_all if str(row.get("node_id") or row.get("dep_node_id") or "") in visible_code_ids]
+    mappings = [
+        row
+        for row in mapping_rows_all
+        if str(row.get("rpg_node_id") or "") in visible_primary_rpg_ids
+    ]
     edges = all_edges
     hidden_counts: Dict[str, Any] = {}
     for key, count in impact_hidden_counts.items():
@@ -1783,8 +1828,8 @@ def add_impact_edges(node_id: str, impact: Dict[str, Any], focus_reason: str) ->
 
     matched_files = {file_path for node in primary_rpg_nodes_all for file_path in node.get("changed_files") or []}
     unmatched_code_deltas = [delta for delta in code_deltas if _code_delta_file(delta) not in matched_files]
-    mapped_code_relations = sum(1 for row in mapping_rows_all if row.get("code_node_id"))
-    missing_mappings = sum(1 for row in mapping_rows_all if row.get("status") == "missing")
+    mapped_code_relations = sum(1 for row in mappings if row.get("code_node_id"))
+    missing_mappings = sum(1 for row in mappings if row.get("status") == "missing")
     diff_anchors = _diff_anchor_map(code_deltas)
     graph_context = {
         "current_graph_available": current_graph_available,
@@ -1814,12 +1859,14 @@ def add_impact_edges(node_id: str, impact: Dict[str, Any], focus_reason: str) ->
         "edges": len(edges),
         "warnings": len(warnings),
         "changed_files": len(changed_files),
+        "hidden_context_nodes": len(hidden_context_nodes),
         "review_status": result.get("type", "review"),
         "apply_status": _apply_status(apply_result),
         "verification_status": _test_status(result, code_result, apply_result),
     }
+    nodes_view["hidden_context_nodes"] = hidden_context_nodes
     nodes_summary = dict(nodes_view.get("summary", {}))
-    for key in ("selected_feature_groups", "mapped_code_relations", "missing_mappings", "review_status", "apply_status", "verification_status"):
+    for key in ("selected_feature_groups", "mapped_code_relations", "missing_mappings", "hidden_context_nodes", "review_status", "apply_status", "verification_status"):
         _set_if_present(nodes_summary, key, summary.get(key))
     nodes_view["summary"] = nodes_summary
     return {
@@ -1830,6 +1877,7 @@ def add_impact_edges(node_id: str, impact: Dict[str, Any], focus_reason: str) ->
         "mappings": mappings,
         "edges": edges,
         "hidden_counts": hidden_counts,
+        "hidden_context_nodes": hidden_context_nodes,
         "warnings": warnings,
         "changed_files": changed_files,
         "unmatched_code_deltas": unmatched_code_deltas,
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index 7d8fced..a9e0f5b 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -136,7 +136,7 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
             "query": "a.py",
             "results": [
                 {"node_id": "n1", "name": "Node", "score": 1.0, "dep_nodes": ["a.py:f"]},
-                {"node_id": "n2", "name": "Missing Node", "score": 0.5},
+                {"node_id": "n2", "name": "Unchanged Node", "score": 0.5, "dep_nodes": ["b.py:g"]},
             ],
         }),
         encoding="utf-8",
@@ -155,9 +155,10 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
                     "impact_summary": {"total_callers": 1, "total_callees": 1, "affected_file_count": 1},
                 },
                 "n2": {
-                    "name": "Missing Node",
-                    "affected_files": [],
-                    "impact_summary": {"total_callers": 0, "affected_file_count": 0},
+                    "name": "Unchanged Node",
+                    "dep_nodes": ["b.py:g"],
+                    "affected_files": ["b.py"],
+                    "impact_summary": {"total_callers": 0, "affected_file_count": 1},
                 }
             },
         }),
@@ -194,16 +195,19 @@ def test_review_publish_report_returns_report_path(tmp_path: Path, monkeypatch)
                 "node_type": "feature",
                 "meta": {"path": "a.py"},
                 "children": [
-                    {"id": "n2", "name": "Missing Node", "node_type": "feature", "meta": {"path": "b.py"}, "children": []},
+                    {"id": "n2", "name": "Unchanged Node", "node_type": "feature", "meta": {"path": "b.py"}, "children": []},
                     {"id": "n3", "name": "Context Node", "node_type": "feature", "meta": {"path": "context.py"}, "children": []},
                 ],
             },
             "edges": [],
             "dep_graph": {
-                "nodes": {"a.py:f": {"name": "f", "type": "function", "module": "a.py", "line_start": 10, "line_end": 12, "rpg_nodes": ["n1"]}},
+                "nodes": {
+                    "a.py:f": {"name": "f", "type": "function", "module": "a.py", "line_start": 10, "line_end": 12, "rpg_nodes": ["n1"]},
+                    "b.py:g": {"name": "g", "type": "function", "module": "b.py", "line_start": 20, "line_end": 22, "rpg_nodes": ["n2"]},
+                },
                 "edges": [],
             },
-            "_dep_to_rpg_map": {"a.py:f": ["n1"]},
+            "_dep_to_rpg_map": {"a.py:f": ["n1"], "b.py:g": ["n2"]},
         }),
         encoding="utf-8",
     )
@@ -300,7 +304,7 @@ def fake_write_command_report(run):
         assert audit["plan"]["affected_nodes"] == ["n1", "n2"]
         assert audit["plan"]["code_changes"] == [{"file_path": "a.py"}]
         assert audit["impact"]["result_count"] == 2
-        assert audit["impact"]["mapped_code_relations"] == 1
+        assert audit["impact"]["mapped_code_relations"] == 2
         assert audit["code"]["commit_sha"] == "abc123"
         assert audit["code"]["files_modified"] == ["a.py"]
         assert audit["apply"]["status"] == "success"
@@ -319,32 +323,38 @@ def fake_write_command_report(run):
         assert not list(tmp_path.glob("rpg_edit_focused_graph_*.html"))
         focused = data["focused_view"]
         assert focused["summary"]["selected_feature_groups"] == 2
+        assert focused["summary"]["primary_rpg_nodes"] == 1
+        assert focused["summary"]["hidden_context_nodes"] == 1
         assert focused["summary"]["mapped_code_relations"] == 1
-        assert focused["summary"]["missing_mappings"] == 1
+        assert focused["summary"]["missing_mappings"] == 0
         assert focused["primary_rpg_nodes"][0]["node_id"] == "n1"
         assert focused["primary_rpg_nodes"][0]["mapping_status"] == "mapped"
         assert focused["primary_rpg_nodes"][0]["changed_files"] == ["a.py"]
         assert focused["primary_code_nodes"][0]["node_id"] == "a.py:f"
         assert focused["primary_code_nodes"][0]["path"] == "a.py"
-        mapping_statuses = {row["status"] for row in focused["mappings"]}
-        assert {"mapped", "missing"}.issubset(mapping_statuses)
+        assert [row["status"] for row in focused["mappings"]] == ["mapped"]
         mapped = next(row for row in focused["mappings"] if row.get("code_node_id") == "a.py:f")
         assert mapped["rpg_node_id"] == "n1"
         assert mapped["changed_files"] == ["a.py"]
-        assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in focused["warnings"])
+        hidden = focused["hidden_context_nodes"][0]
+        assert hidden["node_id"] == "n2"
+        assert hidden["mapping_status"] == "mapped"
+        assert hidden["hidden_reason"] == "selected by plan/impact, hidden because no modified mapped code"
+        assert not any(row["type"] == "missing_mapping" and row.get("node_id") == "n2" for row in focused["warnings"])
         nodes_view = focused["nodes_view"]
         assert nodes_view["summary"]["selected_feature_groups"] == 2
-        assert nodes_view["summary"]["semantic_nodes"] == 2
+        assert nodes_view["summary"]["semantic_nodes"] == 1
+        assert nodes_view["summary"]["hidden_context_nodes"] == 1
         semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
         assert semantic_by_id["n1"]["breadcrumb_path"] == "Node"
         assert semantic_by_id["n1"]["mapping_status"] == "mapped"
         assert semantic_by_id["n1"]["selected"] is True
         assert semantic_by_id["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
-        assert semantic_by_id["n2"]["breadcrumb_path"] == "Node / Missing Node"
-        assert semantic_by_id["n2"]["state"] == "missing_mapping"
-        assert semantic_by_id["n2"]["mapping_status"] == "missing"
-        assert semantic_by_id["n2"]["selected"] is True
+        assert "n2" not in semantic_by_id
         assert "n3" not in semantic_by_id
+        hidden_by_id = {row["node_id"]: row for row in nodes_view["hidden_context_nodes"]}
+        assert hidden_by_id["n2"]["name"] == "Unchanged Node"
+        assert hidden_by_id["n2"]["hidden_reason"] == "selected by plan/impact, hidden because no modified mapped code"
         code = nodes_view["code_nodes"][0]
         assert code["dep_node_id"] == "a.py:f"
         assert code["path"] == "a.py"
@@ -355,7 +365,7 @@ def fake_write_command_report(run):
         bridge_by_rpg = {row["rpg_node_id"]: row for row in nodes_view["mappings"]}
         assert bridge_by_rpg["n1"]["status"] == "mapped"
         assert bridge_by_rpg["n1"]["changed_files"] == [{"path": "a.py", "diff_anchor": "diff-a.py"}]
-        assert bridge_by_rpg["n2"]["state"] == "missing_mapping"
+        assert "n2" not in bridge_by_rpg
         assert nodes_view["hidden_counts"] == {}
         assert nodes_view["summary"]["edges"] == 2
         assert focused["summary"]["edges"] == 2
@@ -366,9 +376,13 @@ def fake_write_command_report(run):
         assert edges_by_relation["callee"]["source_node_id"] == "n1"
         assert edges_by_relation["callee"]["target_node_id"] == "helpers.py:g"
         assert edges_by_relation["callee"]["target_link_id"] == "context-helpers.py-g"
-        assert any(row["type"] == "missing_mapping" and row["node_id"] == "n2" for row in nodes_view["warnings"])
+        assert not any(row["type"] == "missing_mapping" and row.get("node_id") == "n2" for row in nodes_view["warnings"])
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
         hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
+        assert "rpg-n2" not in hierarchy_text
+        assert "code-b.py-g" not in hierarchy_text
+        assert "Unchanged Node" not in hierarchy_text
+        assert "b.py:g" not in hierarchy_text
         assert "rpg-n3" not in hierarchy_text
         assert "Node / Context Node" not in hierarchy_text
         assert '"feature_path": "context.py"' not in hierarchy_text
@@ -390,7 +404,7 @@ def fake_write_command_report(run):
         assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
         assert nodes_view["graph_context"]["current_graph_available"] is True
         assert nodes_view["graph_context"]["current_rpg_nodes"] == 3
-        assert nodes_view["graph_context"]["current_dep_nodes"] == 1
+        assert nodes_view["graph_context"]["current_dep_nodes"] == 2
         assert "+new <unsafe>" not in json.dumps(nodes_view, ensure_ascii=False)
         return report_path
 
@@ -445,7 +459,7 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
 
     validate_path.write_text(json.dumps({"type": "ready"}), encoding="utf-8")
     locate_path.write_text(json.dumps({"type": "candidates", "results": [{"node_id": "other", "name": "Other"}]}), encoding="utf-8")
-    plan_path.write_text(json.dumps({"affected_nodes": ["planned"], "code_changes": [{"file_path": "scripts/common/run_report.py"}]}), encoding="utf-8")
+    plan_path.write_text(json.dumps({"affected_nodes": ["planned", "background"], "code_changes": [{"file_path": "scripts/common/run_report.py"}]}), encoding="utf-8")
     impact_path.write_text(
         json.dumps({
             "type": "impact",
@@ -456,6 +470,12 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
                     "affected_files": ["scripts/common/run_report.py"],
                     "callers": [{"node_id": "tests/test_report.py:test_render_artifacts", "name": "test_render_artifacts", "path": "tests/test_report.py"}],
                     "impact_summary": {"total_callers": 1},
+                },
+                "background": {
+                    "name": "Background Node",
+                    "dep_nodes": ["background.py:helper"],
+                    "affected_files": ["background.py"],
+                    "impact_summary": {"total_callers": 0, "affected_file_count": 1},
                 }
             },
         }),
@@ -500,10 +520,11 @@ def test_review_report_reconstructs_affected_node_evidence_from_impact(tmp_path:
                 "nodes": {
                     dep_id: {"name": "_render_artifacts", "type": "function", "module": "scripts/common/run_report.py", "line_start": 537, "line_end": 564, "rpg_nodes": ["planned"]},
                     "tests/test_report.py:test_render_artifacts": {"name": "test_render_artifacts", "type": "function", "module": "tests/test_report.py", "line_start": 20, "line_end": 40},
+                    "background.py:helper": {"name": "helper", "type": "function", "module": "background.py", "line_start": 5, "line_end": 8, "rpg_nodes": ["background"]},
                 },
                 "edges": [],
             },
-            "_dep_to_rpg_map": {dep_id: ["planned"]},
+            "_dep_to_rpg_map": {dep_id: ["planned"], "background.py:helper": ["background"]},
         }),
         encoding="utf-8",
     )
@@ -588,10 +609,10 @@ def fake_write_command_report(run):
         assert evidence_paths == artifact_paths
         audit = evidence["audit_summary"]
         assert audit["review"]["status"] == "skipped"
-        assert audit["plan"]["affected_nodes"] == ["planned"]
+        assert audit["plan"]["affected_nodes"] == ["planned", "background"]
         assert audit["plan"]["code_changes"] == [{"file_path": "scripts/common/run_report.py"}]
-        assert audit["impact"]["result_count"] == 1
-        assert audit["impact"]["mapped_code_relations"] == 1
+        assert audit["impact"]["result_count"] == 2
+        assert audit["impact"]["mapped_code_relations"] == 2
         assert audit["code"]["files_modified"] == ["scripts/common/run_report.py"]
         assert audit["apply"]["status"] == "dep_refreshed"
         assert audit["apply"]["dep_graph_refreshed"] is True
@@ -606,19 +627,27 @@ def fake_write_command_report(run):
         assert "focused_graph" not in data
         assert not any(item["label"] == "focused_graph" for item in data["artifacts"])
         focused = data["focused_view"]
-        assert focused["summary"]["selected_feature_groups"] == 1
+        assert focused["summary"]["selected_feature_groups"] == 2
+        assert focused["summary"]["primary_rpg_nodes"] == 1
+        assert focused["summary"]["hidden_context_nodes"] == 1
         assert focused["summary"]["mapped_code_relations"] == 1
         assert focused["summary"]["missing_mappings"] == 0
         primary = focused["primary_rpg_nodes"][0]
         assert primary["node_id"] == "planned"
         assert primary["locate_status"] == "missing"
         assert primary["changed_files"] == ["scripts/common/run_report.py"]
+        assert len(focused["primary_rpg_nodes"]) == 1
         mapping = focused["mappings"][0]
         assert mapping["code_node_id"] == dep_id
         assert "impact" in mapping["source"]
+        hidden = focused["hidden_context_nodes"][0]
+        assert hidden["node_id"] == "background"
+        assert hidden["mapping_status"] == "mapped"
+        assert hidden["hidden_reason"] == "selected by plan/impact, hidden because no modified mapped code"
         nodes_view = focused["nodes_view"]
-        assert nodes_view["summary"]["selected_feature_groups"] == 1
+        assert nodes_view["summary"]["selected_feature_groups"] == 2
         assert nodes_view["summary"]["semantic_nodes"] == 1
+        assert nodes_view["summary"]["hidden_context_nodes"] == 1
         semantic_by_id = {row["node_id"]: row for row in nodes_view["semantic_nodes"]}
         semantic = semantic_by_id["planned"]
         assert semantic["breadcrumb_path"] == "Planned Node"
@@ -627,6 +656,9 @@ def fake_write_command_report(run):
         assert semantic["selected"] is True
         assert semantic["changed_files"] == [{"path": "scripts/common/run_report.py", "diff_anchor": "diff-scripts_common_run_report.py"}]
         assert "background" not in semantic_by_id
+        hidden_by_id = {row["node_id"]: row for row in nodes_view["hidden_context_nodes"]}
+        assert hidden_by_id["background"]["name"] == "Background Node"
+        assert hidden_by_id["background"]["hidden_reason"] == "selected by plan/impact, hidden because no modified mapped code"
         code = nodes_view["code_nodes"][0]
         assert code["dep_node_id"] == dep_id
         assert code["path"] == "scripts/common/run_report.py"
@@ -648,6 +680,8 @@ def fake_write_command_report(run):
         assert nodes_view["hierarchy"]["id"] == "focused-graph-root"
         hierarchy_text = json.dumps(nodes_view["hierarchy"], ensure_ascii=False)
         assert "rpg-background" not in hierarchy_text
+        assert "code-background.py-helper" not in hierarchy_text
+        assert "background.py:helper" not in hierarchy_text
         assert '"feature_path": "Planned Node"' in hierarchy_text
         assert '"feature_path": "scripts/common/run_report.py"' not in hierarchy_text
         assert "Mapped code" not in hierarchy_text
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index 8245d7c..cff808a 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -255,6 +255,16 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
                         },
                     ],
                     "hidden_counts": {"callers": 3},
+                    "hidden_context_nodes": [
+                        {
+                            "node_id": "hidden<script>",
+                            "link_id": "rpg-hidden-script",
+                            "name": "Hidden <unsafe>",
+                            "path": "hidden.py<script>",
+                            "mapping_status": "mapped",
+                            "hidden_reason": "selected by plan/impact, hidden because no modified mapped code <reason>",
+                        }
+                    ],
                     "warnings": [
                         {"type": "missing_mapping", "message": "Missing <mapping>", "node_id": "n2", "node_link_id": "rpg-n2"},
                         {"type": "missing_reason", "message": "Missing <reason>", "node_id": "n3"},
@@ -508,6 +518,13 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "too_many_neighbors" not in html
     assert "stale_graph" in html
     assert "Hidden 3 additional caller neighbors." in html
+    assert "Hidden context nodes" in html
+    assert "hidden&lt;script&gt;" in html
+    assert "Hidden &lt;unsafe&gt;" in html
+    assert "hidden.py&lt;script&gt;" in html
+    assert "selected by plan/impact, hidden because no modified mapped code &lt;reason&gt;" in html
+    assert "Hidden <unsafe>" not in html
+    assert "hidden.py<script>" not in html
     assert '"edges": 1' not in html
     assert html.count("+line 0 &lt;script&gt;alert(0)&lt;/script&gt;") == 1
     assert "+line 0 <script>alert(0)</script>" not in html
@@ -524,9 +541,14 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert graph_payload["summary"]["relation_edges"] == 3
     assert graph_payload["summary"]["context_edges"] == 3
     assert any(node.get("id") == "rpg-background" for node in graph_payload["hierarchy"]["children"])
+    assert graph_payload["hidden_context_nodes"][0]["node_id"] == "hidden<script>"
+    assert graph_payload["hidden_context_nodes"][0]["hidden_reason"] == "selected by plan/impact, hidden because no modified mapped code <reason>"
     relation_links = [link for link in graph_payload["links"] if link.get("relation") != "contains"]
     assert len(relation_links) == 3
     nodes_by_id = {node["id"]: node for node in graph_payload["nodes"]}
+    assert "rpg-hidden-script" not in nodes_by_id
+    assert not any(link.get("source") == "rpg-hidden-script" or link.get("target") == "rpg-hidden-script" for link in graph_payload["links"])
+    assert "rpg-hidden-script" not in graph_payload["node_aliases"]
     assert nodes_by_id["rpg-n1-script"]["symbol"] == "NodeSymbol <unsafe>"
     assert nodes_by_id["rpg-n1-script"]["reason"] == "selected <reason>"
     assert len(nodes_by_id["rpg-n1-script"]["mapped_code"]) == 2
@@ -562,6 +584,8 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "focusedNodeIds.has(d.id) || focusedCodeLinkIds.has(d.id)" not in html
     assert "rpg-background" not in default_focus["focused_tree_node_ids"]
     assert "context-callee-script" not in default_focus["focused_tree_node_ids"]
+    assert "rpg-hidden-script" not in default_focus["node_link_ids"]
+    assert "rpg-hidden-script" not in default_focus["focused_tree_node_ids"]
     assert graph_payload["hidden_counts"] == {"callers": 3}
     inspector_json = html.split("<summary>Inspector JSON</summary><pre>", 1)[1].split("</pre>", 1)[0]
     assert "focused_graph" in inspector_json
@@ -569,6 +593,9 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "semantic_nodes" in inspector_json
     assert "hierarchy" in inspector_json
     assert "default_focus" in inspector_json
+    assert "hidden_context_nodes" in inspector_json
+    assert "hidden&lt;script&gt;" in inspector_json
+    assert "selected by plan/impact, hidden because no modified mapped code &lt;reason&gt;" in inspector_json
     assert "primary_rpg_nodes" not in inspector_json
     assert "primary_code_nodes" not in inspector_json
     assert "caps" not in inspector_json

From 9d031fb138f2de234cc8d2cb9b9581de01b3d0d0 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Thu, 9 Jul 2026 11:13:46 +0000
Subject: [PATCH 54/56] rpg_edit: In _render_page() CSS at lines 395-403, add
 in-browser fulls

---
 CoderMind/scripts/common/run_report.py | 40 ++++++++++++++++++++++----
 CoderMind/tests/test_run_report.py     | 25 +++++++++++++++-
 2 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/CoderMind/scripts/common/run_report.py b/CoderMind/scripts/common/run_report.py
index a17be4e..65ce20d 100644
--- a/CoderMind/scripts/common/run_report.py
+++ b/CoderMind/scripts/common/run_report.py
@@ -393,11 +393,18 @@ def _render_page(
 .focus-links {{ display:flex; flex-wrap:wrap; gap:6px; }}
 .focus-link {{ border:1px solid var(--line); border-radius:999px; padding:2px 8px; background:#fff; font-size:12px; }}
 .focused-graph-section {{ overflow-x:hidden; }}
+body.focused-graph-fullscreen-active {{ overflow:hidden; }}
+.focused-graph-section.focused-graph-fullscreen {{ position:fixed; inset:0; z-index:9999; margin:0; padding:0; background:#020617; overflow:hidden; }}
+.focused-graph-section.focused-graph-fullscreen > h2, .focused-graph-section.focused-graph-fullscreen > .focus-summary, .focused-graph-section.focused-graph-fullscreen > details {{ display:none; }}
+.focused-graph-section.focused-graph-fullscreen .focused-graph-stage {{ width:100vw; height:100vh; border:0; border-radius:0; }}
 .focused-graph-stage {{ border:1px solid #334155; border-radius:12px; background:#0f172a; height:clamp(520px,72vh,820px); position:relative; overflow:hidden; }}
 .focused-graph-svg {{ display:block; width:100%; height:100%; cursor:grab; touch-action:none; }}
 .focused-graph-svg:active {{ cursor:grabbing; }}
 .focused-graph-toolbar {{ position:absolute; top:14px; left:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; align-items:center; max-width:calc(100% - 28px); margin:0; padding:10px; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.92); color:#e5e7eb; box-shadow:0 14px 32px rgba(2,6,23,.35); }}
 .focused-graph-toolbar button, .focused-graph-toolbar input {{ border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb; padding:6px 10px; font:inherit; }}
+.focused-graph-toolbar button {{ cursor:pointer; }}
+.focused-graph-toolbar button:hover, .focused-graph-toolbar button:focus-visible {{ border-color:#60a5fa; background:#334155; }}
+.focused-graph-toolbar button[aria-pressed="true"] {{ background:#1d4ed8; border-color:#93c5fd; color:#eff6ff; }}
 .focused-graph-toolbar input::placeholder {{ color:#94a3b8; }}
 .focused-graph-toolbar label {{ display:inline-flex; gap:6px; align-items:center; color:#cbd5e1; }}
 .focused-graph-detail {{ position:absolute; top:14px; right:14px; z-index:2; width:min(320px,calc(100% - 28px)); max-height:calc(100% - 28px); overflow:auto; border:1px solid #334155; border-radius:12px; background:rgba(15,23,42,.94); color:#e5e7eb; padding:12px; box-shadow:0 18px 40px rgba(2,6,23,.35); }}
@@ -1383,12 +1390,14 @@ def _focused_graph_runtime() -> str:
   const fallback = section.querySelector('[data-focused-graph-fallback]');
   const statusEl = section.querySelector('[data-focused-graph-status]');
   const detailEl = section.querySelector('[data-focused-graph-detail]');
+  const fullscreenButton = section.querySelector('[data-action="fullscreen"]');
   if (!window.d3 || !dataEl || !svg) return;
   if (fallback) fallback.hidden = true;
   const data = JSON.parse(dataEl.textContent || '{}');
   const svgSelection = d3.select(svg);
   let width = 960;
   let height = 680;
+  let isFullscreen = false;
 
   function refreshGraphViewport() {
     const svgBox = svg.getBoundingClientRect();
@@ -1397,6 +1406,21 @@ def _focused_graph_runtime() -> str:
     height = Math.max(360, Math.round(svgBox.height || stageBox.height || svg.clientHeight || 680));
     svgSelection.attr('viewBox', `0 0 ${width} ${height}`);
   }
+
+  function updateFullscreenButton() {
+    if (!fullscreenButton) return;
+    fullscreenButton.textContent = isFullscreen ? 'Restore embedded' : 'Fullscreen';
+    fullscreenButton.setAttribute('aria-pressed', isFullscreen ? 'true' : 'false');
+  }
+
+  function toggleFullscreen() {
+    isFullscreen = !isFullscreen;
+    section.classList.toggle('focused-graph-fullscreen', isFullscreen);
+    document.body.classList.toggle('focused-graph-fullscreen-active', isFullscreen);
+    updateFullscreenButton();
+    scheduleResize();
+  }
+
   refreshGraphViewport();
   const defaultFocus = data.default_focus || {};
   const defaultShowEdges = defaultFocus.show_edges !== false;
@@ -1788,9 +1812,10 @@ def _focused_graph_runtime() -> str:
       });
     nodeEnter.append('circle').attr('r', d => d._children ? 6 : (d.children ? 5 : 4));
     nodeEnter.append('text')
-      .attr('dy', 4)
-      .attr('x', d => d.children || d._children ? -10 : 10)
-      .attr('text-anchor', d => d.children || d._children ? 'end' : 'start')
+      .attr('x', d => d.children || d._children ? 0 : 10)
+      .attr('y', d => d.children || d._children ? 14 : 0)
+      .attr('dy', d => d.children || d._children ? 8 : 4)
+      .attr('text-anchor', d => d.children || d._children ? 'middle' : 'start')
       .attr('font-size', 12)
       .attr('fill', '#e5e7eb')
       .text(d => nodeLabel(d).length > 46 ? nodeLabel(d).slice(0, 44) + '…' : nodeLabel(d));
@@ -1805,8 +1830,10 @@ def _focused_graph_runtime() -> str:
       .attr('class', d => `focused-graph-node${d.id === selectedId ? ' selected' : ''}${isDefaultFocused(d) ? ' focused' : ' non-focused'}${nodeMatches(d) ? ' search-match' : ''}${selectedId && d.id !== selectedId && !currentRelationEdges.some(edge => edge._source.id === d.id || edge._target.id === d.id) ? ' dimmed' : ''}`);
     nodeUpdate.select('circle').attr('r', d => d._children ? 6 : (d.children ? 5 : 4));
     nodeUpdate.select('text')
-      .attr('x', d => d.children || d._children ? -10 : 10)
-      .attr('text-anchor', d => d.children || d._children ? 'end' : 'start');
+      .attr('x', d => d.children || d._children ? 0 : 10)
+      .attr('y', d => d.children || d._children ? 14 : 0)
+      .attr('dy', d => d.children || d._children ? 8 : 4)
+      .attr('text-anchor', d => d.children || d._children ? 'middle' : 'start');
     node.exit().transition().duration(180).attr('transform', `translate(${source.y || 0},${source.x || 0})`).remove();
 
     const treeLinks = layout.links();
@@ -1844,7 +1871,9 @@ def _focused_graph_runtime() -> str:
     window.addEventListener('resize', scheduleResize);
   }
 
+  updateFullscreenButton();
   section.querySelector('[data-action="reset"]')?.addEventListener('click', resetDefault);
+  fullscreenButton?.addEventListener('click', toggleFullscreen);
   section.querySelector('[data-action="edges"]')?.addEventListener('change', event => { showEdges = event.target.checked; update(root); });
   section.querySelector('[data-action="search"]')?.addEventListener('input', event => { query = text(event.target.value).toLowerCase(); update(root); });
   update(root);
@@ -1886,6 +1915,7 @@ def _render_focused_graph(focused_view: dict[str, Any], file_anchors: Mapping[st
     controls = (
         '<div class="focused-graph-toolbar">'
         '<button type="button" data-action="reset">Reset default</button>'
+        '<button type="button" data-action="fullscreen" aria-pressed="false">Fullscreen</button>'
         '<label><input type="checkbox" data-action="edges" checked> Edges</label>'
         '<input type="search" data-action="search" placeholder="Search nodes" aria-label="Search focused graph nodes">'
         f'<span class="badge" data-focused-graph-status>Visible relation edges: 0/{relation_edge_total}</span>'
diff --git a/CoderMind/tests/test_run_report.py b/CoderMind/tests/test_run_report.py
index cff808a..1c7d63c 100644
--- a/CoderMind/tests/test_run_report.py
+++ b/CoderMind/tests/test_run_report.py
@@ -393,7 +393,7 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "main { max-width:1440px;" in html
     assert "height=\"680\"" not in html
     assert "width=\"960\"" not in html
-    assert '<div class="focused-graph-stage"><div class="focused-graph-toolbar">' in html
+    assert '<div class="focused-graph-stage"><div class="focused-graph-toolbar"><button type="button" data-action="reset">Reset default</button><button type="button" data-action="fullscreen" aria-pressed="false">Fullscreen</button>' in html
     assert '<div class="focused-graph-legend" aria-label="Focused graph legend">' in html
     assert "Focused nodes map" not in html
     assert "semantic-code impact chain" not in html
@@ -409,6 +409,8 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "https://d3js.org v7.9.0" in html
     assert "<script src=" not in html
     assert "data-action=\"reset\"" in html
+    assert "data-action=\"fullscreen\"" in html
+    assert "aria-pressed=\"false\">Fullscreen</button>" in html
     assert "data-action=\"expand-all\"" not in html
     assert "data-action=\"depth-plus\"" not in html
     assert "data-action=\"depth-minus\"" not in html
@@ -436,10 +438,15 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "focused-graph-node.hidden" in html
     assert "focused-graph-link.active" in html
     assert "focused-graph-link.dimmed" in html
+    assert "body.focused-graph-fullscreen-active { overflow:hidden; }" in html
+    assert ".focused-graph-section.focused-graph-fullscreen { position:fixed; inset:0; z-index:9999; margin:0; padding:0; background:#020617; overflow:hidden; }" in html
+    assert ".focused-graph-section.focused-graph-fullscreen .focused-graph-stage { width:100vw; height:100vh; border:0; border-radius:0; }" in html
     assert ".focused-graph-stage { border:1px solid #334155; border-radius:12px; background:#0f172a; height:clamp(520px,72vh,820px);" in html
     assert ".focused-graph-svg { display:block; width:100%; height:100%;" in html
     assert ".focused-graph-toolbar { position:absolute; top:14px; left:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; align-items:center; max-width:calc(100% - 28px); margin:0;" in html
     assert ".focused-graph-toolbar button, .focused-graph-toolbar input { border:1px solid #475569; border-radius:8px; background:#1e293b; color:#e5e7eb;" in html
+    assert ".focused-graph-toolbar button { cursor:pointer; }" in html
+    assert ".focused-graph-toolbar button[aria-pressed=\"true\"] { background:#1d4ed8; border-color:#93c5fd; color:#eff6ff; }" in html
     assert ".focused-graph-legend { position:absolute; left:14px; bottom:14px; z-index:3; display:flex; flex-wrap:wrap; gap:8px; max-width:calc(100% - 28px); margin:0;" in html
     assert ".focused-graph-detail { position:absolute; top:14px; right:14px;" in html
     assert "rootHierarchyId" in html
@@ -447,13 +454,29 @@ def test_common_run_report_write_command_report_renders_retrievals_code_deltas_a
     assert "visibleEndpoint" in html
     assert "updateStatus" in html
     assert "const svgSelection = d3.select(svg);" in html
+    assert "const fullscreenButton = section.querySelector('[data-action=\"fullscreen\"]');" in html
+    assert "let isFullscreen = false;" in html
     assert "function refreshGraphViewport()" in html
+    assert "function updateFullscreenButton()" in html
+    assert "function toggleFullscreen()" in html
+    assert "fullscreenButton.textContent = isFullscreen ? 'Restore embedded' : 'Fullscreen';" in html
+    assert "fullscreenButton.setAttribute('aria-pressed', isFullscreen ? 'true' : 'false');" in html
+    assert "section.classList.toggle('focused-graph-fullscreen', isFullscreen);" in html
+    assert "document.body.classList.toggle('focused-graph-fullscreen-active', isFullscreen);" in html
+    assert "fullscreenButton?.addEventListener('click', toggleFullscreen);" in html
+    assert "scheduleResize();" in html
     assert "svg.getBoundingClientRect()" in html
     assert "stage.getBoundingClientRect()" in html
     assert "svgSelection.attr('viewBox', `0 0 ${width} ${height}`);" in html
     assert "window.ResizeObserver" in html
     assert "new ResizeObserver(scheduleResize)" in html
     assert "window.requestAnimationFrame" in html
+    assert ".attr('x', d => d.children || d._children ? 0 : 10)" in html
+    assert ".attr('y', d => d.children || d._children ? 14 : 0)" in html
+    assert ".attr('dy', d => d.children || d._children ? 8 : 4)" in html
+    assert ".attr('text-anchor', d => d.children || d._children ? 'middle' : 'start')" in html
+    assert "d.children || d._children ? -10 : 10" not in html
+    assert "d.children || d._children ? 'end' : 'start'" not in html
     assert "Number(svg.getAttribute('width'))" not in html
     assert "Number(svg.getAttribute('height'))" not in html
     assert "const visible = showEdges ? currentRelationEdges.length : 0;" in html

From 401ec8871b6da902c4f780416fbbc8965d08cae3 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Fri, 10 Jul 2026 03:07:45 +0000
Subject: [PATCH 55/56] encode: recover from corrupt RPG file

Prompt before deleting a damaged rpg.json so /cmind.encode can safely rerun instead of leaving users blocked.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/templates/commands/encode.md  | 20 ++++++++++++++++++--
 CoderMind/tests/test_encode_commands.py |  9 +++++++++
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/CoderMind/templates/commands/encode.md b/CoderMind/templates/commands/encode.md
index 4292e03..a32d3c5 100644
--- a/CoderMind/templates/commands/encode.md
+++ b/CoderMind/templates/commands/encode.md
@@ -30,8 +30,24 @@ Inspect the `type` field in the output:
 
 **If type is "error"**:
 
-* Display the error message and stop. The RPG file may be corrupted.
-* Suggest deleting the invalid file and re-running `/cmind.encode`.
+* Display the error message and the `rpg_file` path. Explain that the
+  existing RPG file appears corrupted and blocks encoding.
+* Ask the user whether to delete the damaged RPG file and run a full encode now:
+
+  ```text
+  The RPG file appears to be corrupted:
+    <rpg_file>
+
+  Delete this file and run a full /cmind.encode now?
+  - Y: Delete <rpg_file> and run full encode
+  - N: Quit without deleting anything
+  ```
+
+* If user chooses **Y**: delete exactly the returned `rpg_file` path with
+  `rm -- "<rpg_file>"`, then proceed to Step 2 in this same command run.
+  Do not delete directories, globs, or any other candidate RPG paths.
+* If user chooses **N**: terminate without deleting anything.
+* If deletion fails: display the deletion error and stop.
 
 **If type is "init"**:
 
diff --git a/CoderMind/tests/test_encode_commands.py b/CoderMind/tests/test_encode_commands.py
index 795c574..dbf7f3e 100644
--- a/CoderMind/tests/test_encode_commands.py
+++ b/CoderMind/tests/test_encode_commands.py
@@ -771,6 +771,15 @@ def test_encode_template_references_check_script(self):
         assert "check_encode.py" in content
         assert "run_encode.py" in content
 
+    def test_encode_template_recovers_from_corrupt_rpg(self):
+        encode_md = os.path.join(self._template_dir, "encode.md")
+        with open(encode_md, "r", encoding="utf-8") as f:
+            content = f.read()
+        assert "Delete this file and run a full /cmind.encode now?" in content
+        assert "rm -- \"<rpg_file>\"" in content
+        assert "proceed to Step 2" in content
+        assert "Quit without deleting anything" in content
+
     def test_update_rpg_template_references_check_script(self):
         update_md = os.path.join(self._template_dir, "update_rpg.md")
         with open(update_md, "r", encoding="utf-8") as f:

From 4064f9cd258f7691852218d5f46b817f8eff46f0 Mon Sep 17 00:00:00 2001
From: Qingtao Li <qingtaoli@microsoft.com>
Date: Mon, 13 Jul 2026 04:41:47 +0000
Subject: [PATCH 56/56] rpg_edit: align focused graph semantic containers

Use semantic RPG container nodes in focused graph reports so reports and deltas preserve canonical links for feature groups.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
---
 CoderMind/scripts/rpg_edit/review.py        | 109 ++++++++++++++++++--
 CoderMind/scripts/update_graphs.py          | 103 ++++++++++++++++--
 CoderMind/tests/test_rpg_edit_run_report.py |  53 +++++++++-
 3 files changed, 248 insertions(+), 17 deletions(-)

diff --git a/CoderMind/scripts/rpg_edit/review.py b/CoderMind/scripts/rpg_edit/review.py
index 30a6acd..082971d 100644
--- a/CoderMind/scripts/rpg_edit/review.py
+++ b/CoderMind/scripts/rpg_edit/review.py
@@ -635,6 +635,67 @@ def feature_path_text(node: Dict[str, Any], group_parts: List[str], feature_name
                 return " / ".join(parts)
         return " / ".join(group_parts + ([feature_name] if feature_name else []))
 
+    def semantic_tree_kind(node: Dict[str, Any]) -> str:
+        node_type = str(node.get("node_type") or node.get("type") or "").lower()
+        if node_type in {"feature_group", "category", "functional_area", "root"}:
+            return node_type
+        return "feature"
+
+    def semantic_full_path_parts(node: Dict[str, Any], group_parts: List[str], feature_name: str) -> List[str]:
+        return _hierarchy_segments(feature_path_text(node, group_parts, feature_name))
+
+    semantic_node_by_path: Dict[str, Dict[str, Any]] = {}
+    for semantic_node in semantic_nodes:
+        semantic_name = str(semantic_node.get("name") or semantic_node.get("symbol") or semantic_node.get("node_id") or "")
+        semantic_parts = semantic_full_path_parts(semantic_node, _semantic_hierarchy_parts(semantic_node), semantic_name)
+        if semantic_parts:
+            semantic_node_by_path.setdefault(" / ".join(semantic_parts), semantic_node)
+
+    def merge_semantic_metadata(row: Dict[str, Any], node: Dict[str, Any], feature_name: str, feature_path: str) -> None:
+        node_id = str(node.get("node_id") or "")
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node_id))
+        row["name"] = feature_name
+        row["feature_name"] = feature_name
+        row["feature_path"] = feature_path
+        row["kind"] = semantic_tree_kind(node)
+        if node_id:
+            row["node_id"] = node_id
+        row["aliases"] = _ordered_unique(_listify(row.get("aliases")) + [node_id, link_id, _node_link_id("feature-path", feature_path)])
+        _set_if_present(row, "state", node.get("state"))
+        _set_if_present(row, "mapping_status", node.get("mapping_status"))
+        for key in (
+            "type",
+            "node_type",
+            "path",
+            "breadcrumb",
+            "breadcrumb_path",
+            "locate_status",
+            "score",
+            "reason",
+            "apply_action",
+            "changed_files",
+            "hidden_counts",
+            "warning_types",
+            "source",
+        ):
+            _set_if_present(row, key, node.get(key))
+
+    def append_or_merge_hierarchy_leaf(parent: Dict[str, Any], leaf: Dict[str, Any]) -> None:
+        children = parent.setdefault("children", [])
+        leaf_id = leaf.get("id")
+        for child in children:
+            if not isinstance(child, dict) or child.get("id") != leaf_id:
+                continue
+            incoming_children = [item for item in _listify(leaf.get("children")) if isinstance(item, dict)]
+            for key, value in leaf.items():
+                if key == "children" or value in (None, ""):
+                    continue
+                child[key] = value
+            for grandchild in incoming_children:
+                _append_hierarchy_leaf(child, grandchild)
+            return
+        children.append(leaf)
+
     attached_endpoint_ids: set[str] = set()
 
     def make_code_leaf(ref: Dict[str, Any]) -> Dict[str, Any]:
@@ -732,20 +793,29 @@ def endpoint_group(parent: Dict[str, Any], owner_id: str, name: str, kind: str)
         trail: List[str] = []
         for part in group_parts:
             trail.append(part)
-            group = _hierarchy_child(parent, _node_link_id("feature-path", "/".join(trail)), part, "feature_group")
-            group["feature_name"] = part
-            group["feature_path"] = " / ".join(trail)
+            group_path = " / ".join(trail)
+            group_node = semantic_node_by_path.get(group_path)
+            if group_node:
+                group_node_id = str(group_node.get("node_id") or "")
+                group = _hierarchy_child(parent, str(group_node.get("link_id") or _node_link_id("rpg", group_node_id)), part, semantic_tree_kind(group_node))
+                merge_semantic_metadata(group, group_node, part, group_path)
+            else:
+                group = _hierarchy_child(parent, _node_link_id("feature-path", "/".join(trail)), part, "feature_group")
+                group["feature_name"] = part
+                group["feature_path"] = group_path
             merge_code_metadata(group, code_refs)
             parent = group
+        leaf_feature_path = feature_path_text(node, group_parts, feature_name)
         leaf: Dict[str, Any] = {
             "id": link_id,
             "node_id": node_id,
             "name": feature_name,
             "feature_name": feature_name,
-            "feature_path": feature_path_text(node, group_parts, feature_name),
-            "kind": "feature",
+            "feature_path": leaf_feature_path,
+            "kind": semantic_tree_kind(node),
             "state": node.get("state"),
             "mapping_status": node.get("mapping_status"),
+            "aliases": _ordered_unique([node_id, link_id, _node_link_id("feature-path", leaf_feature_path)]),
         }
         for key in (
             "type",
@@ -769,7 +839,7 @@ def endpoint_group(parent: Dict[str, Any], owner_id: str, name: str, kind: str)
             if context_group is None:
                 context_group = endpoint_group(leaf, link_id, "Relation endpoints", "context_group")
             append_endpoint(context_group, ref)
-        _append_hierarchy_leaf(parent, leaf)
+        append_or_merge_hierarchy_leaf(parent, leaf)
 
     root_context_group: Optional[Dict[str, Any]] = None
     for edge in edges:
@@ -826,6 +896,20 @@ def remember_path(alias: Any, path_ids: List[str]) -> None:
         for node in semantic_nodes
         if node.get("node_id") not in (None, "")
     }
+    semantic_link_by_path: Dict[str, str] = {}
+    for node in semantic_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        feature_name = str(node.get("name") or node.get("symbol") or node.get("node_id") or "")
+        full_parts: List[str] = []
+        for key in ("breadcrumb_path", "feature_path"):
+            full_parts = _hierarchy_segments(node.get(key))
+            if full_parts:
+                break
+        if not full_parts:
+            full_parts = _semantic_hierarchy_parts(node) + ([feature_name] if feature_name else [])
+        if full_parts:
+            semantic_link_by_path.setdefault(" / ".join(full_parts), link_id)
+
     semantic_path_ids_by_link: Dict[str, List[str]] = {}
     for node in semantic_nodes:
         link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
@@ -833,7 +917,8 @@ def remember_path(alias: Any, path_ids: List[str]) -> None:
         path_ids: List[str] = ["focused-graph-root"]
         for part in _semantic_hierarchy_parts(node):
             trail.append(part)
-            path_ids.append(_node_link_id("feature-path", "/".join(trail)))
+            group_path = " / ".join(trail)
+            path_ids.append(semantic_link_by_path.get(group_path) or _node_link_id("feature-path", "/".join(trail)))
         path_ids.append(link_id)
         semantic_path_ids_by_link[link_id] = path_ids
         remember_path(link_id, path_ids)
@@ -2217,6 +2302,12 @@ def _publish_review_report(
     candidates = _selected_candidate_rows(artifacts)
     code_deltas = _code_delta_rows(artifacts)
     focused_view = _feature_evidence_groups(artifacts, candidates, code_deltas, result)
+    visible_rpg_ids = {
+        str(row.get("node_id"))
+        for row in focused_view.get("primary_rpg_nodes", [])
+        if isinstance(row, dict) and row.get("node_id") not in (None, "")
+    }
+    rpg_delta_rows = [row for row in candidates if str(row.get("node_id") or "") in visible_rpg_ids] if visible_rpg_ids else candidates
     artifact_rows = _artifact_links(plan_path, impact_path, internal_report_paths)
     evidence = _compact_review_evidence(artifacts, artifact_rows, result)
     try:
@@ -2238,7 +2329,7 @@ def _publish_review_report(
                     path=row.get("path") or row.get("meta_path"),
                     score=row.get("score"),
                 )
-                for row in candidates
+                for row in rpg_delta_rows
             ],
             dep_graph_deltas=[
                 DepGraphDeltaEvent(
@@ -2247,7 +2338,7 @@ def _publish_review_report(
                     source_feature=row.get("source_feature"),
                     change=row.get("change"),
                 )
-                for row in _dep_node_rows(candidates)
+                for row in _dep_node_rows(rpg_delta_rows)
             ],
             retrievals=[
                 RetrievalEvent(query=row.get("query"), tool=row.get("tool"), hits=row.get("hits"), reason=row.get("reason"))
diff --git a/CoderMind/scripts/update_graphs.py b/CoderMind/scripts/update_graphs.py
index d1c07b6..d74112c 100644
--- a/CoderMind/scripts/update_graphs.py
+++ b/CoderMind/scripts/update_graphs.py
@@ -533,6 +533,71 @@ def feature_path_text(node: dict[str, Any], group_parts: list[str], feature_name
                 return " / ".join(parts)
         return " / ".join(group_parts + ([feature_name] if feature_name else []))
 
+    def semantic_tree_kind(node: dict[str, Any]) -> str:
+        node_type = str(node.get("node_type") or node.get("type") or "").lower()
+        if node_type in {"feature_group", "category", "functional_area", "root"}:
+            return node_type
+        return "feature"
+
+    def semantic_full_path_parts(node: dict[str, Any], group_parts: list[str], feature_name: str) -> list[str]:
+        return _hierarchy_segments(feature_path_text(node, group_parts, feature_name))
+
+    semantic_node_by_path: dict[str, dict[str, Any]] = {}
+    for semantic_node in semantic_nodes:
+        semantic_name = str(semantic_node.get("name") or semantic_node.get("symbol") or semantic_node.get("node_id") or "")
+        semantic_parts = semantic_full_path_parts(semantic_node, _semantic_hierarchy_parts(semantic_node), semantic_name)
+        if semantic_parts:
+            semantic_node_by_path.setdefault(" / ".join(semantic_parts), semantic_node)
+
+    def merge_semantic_metadata(row: dict[str, Any], node: dict[str, Any], feature_name: str, feature_path: str) -> None:
+        node_id = str(node.get("node_id") or "")
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node_id))
+        row["name"] = feature_name
+        row["feature_name"] = feature_name
+        row["feature_path"] = feature_path
+        row["kind"] = semantic_tree_kind(node)
+        if node_id:
+            row["node_id"] = node_id
+        row["aliases"] = _ordered_unique_text(_listify(row.get("aliases")) + [node_id, link_id, _node_link_id("feature-path", feature_path)])
+        _set_if_present(row, "state", node.get("state"))
+        _set_if_present(row, "mapping_status", node.get("mapping_status"))
+        for key in (
+            "type",
+            "node_type",
+            "path",
+            "breadcrumb",
+            "breadcrumb_path",
+            "changed_files",
+            "hidden_counts",
+            "warning_types",
+            "source",
+            "mapped_code",
+            "mapped_code_node_ids",
+            "mapped_code_link_ids",
+            "mapped_code_paths",
+            "mapped_code_symbols",
+            "mapped_code_path",
+            "mapped_code_symbol",
+            "mapped_code_count",
+        ):
+            _set_if_present(row, key, node.get(key))
+
+    def append_or_merge_hierarchy_leaf(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
+        children = parent.setdefault("children", [])
+        leaf_id = leaf.get("id")
+        for child in children:
+            if not isinstance(child, dict) or child.get("id") != leaf_id:
+                continue
+            incoming_children = [item for item in _listify(leaf.get("children")) if isinstance(item, dict)]
+            for key, value in leaf.items():
+                if key == "children" or value in (None, ""):
+                    continue
+                child[key] = value
+            for grandchild in incoming_children:
+                _append_hierarchy_leaf(child, grandchild)
+            return
+        children.append(leaf)
+
     def endpoint_group(parent: dict[str, Any], owner_id: str, name: str, kind: str) -> dict[str, Any]:
         return _hierarchy_child(parent, _node_link_id(kind, owner_id), name, kind)
 
@@ -574,19 +639,28 @@ def append_endpoint(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
         trail: list[str] = []
         for part in group_parts:
             trail.append(part)
-            group = _hierarchy_child(parent, _node_link_id("feature-path", "/".join(trail)), part, "feature_group")
-            group["feature_name"] = part
-            group["feature_path"] = " / ".join(trail)
+            group_path = " / ".join(trail)
+            group_node = semantic_node_by_path.get(group_path)
+            if group_node:
+                group_node_id = str(group_node.get("node_id") or "")
+                group = _hierarchy_child(parent, str(group_node.get("link_id") or _node_link_id("rpg", group_node_id)), part, semantic_tree_kind(group_node))
+                merge_semantic_metadata(group, group_node, part, group_path)
+            else:
+                group = _hierarchy_child(parent, _node_link_id("feature-path", "/".join(trail)), part, "feature_group")
+                group["feature_name"] = part
+                group["feature_path"] = group_path
             parent = group
+        leaf_feature_path = feature_path_text(node, group_parts, feature_name)
         leaf: dict[str, Any] = {
             "id": link_id,
             "node_id": node_id,
             "name": feature_name,
             "feature_name": feature_name,
-            "feature_path": feature_path_text(node, group_parts, feature_name),
-            "kind": "feature",
+            "feature_path": leaf_feature_path,
+            "kind": semantic_tree_kind(node),
             "state": node.get("state"),
             "mapping_status": node.get("mapping_status"),
+            "aliases": _ordered_unique_text([node_id, link_id, _node_link_id("feature-path", leaf_feature_path)]),
         }
         for key in (
             "type",
@@ -608,7 +682,7 @@ def append_endpoint(parent: dict[str, Any], leaf: dict[str, Any]) -> None:
             "mapped_code_count",
         ):
             _set_if_present(leaf, key, node.get(key))
-        _append_hierarchy_leaf(parent, leaf)
+        append_or_merge_hierarchy_leaf(parent, leaf)
 
     root_context_group: Optional[dict[str, Any]] = None
     known_links = {str(node.get("link_id") or "") for node in semantic_nodes}
@@ -678,6 +752,20 @@ def remember_path(alias: Any, path_ids: list[str]) -> None:
             return
         hierarchy_paths_by_link.setdefault(str(alias), path_ids)
 
+    semantic_link_by_path: dict[str, str] = {}
+    for node in semantic_nodes:
+        link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
+        feature_name = str(node.get("name") or node.get("symbol") or node.get("node_id") or "")
+        full_parts: list[str] = []
+        for key in ("feature_path", "breadcrumb_path", "breadcrumb", "path"):
+            full_parts = _hierarchy_segments(node.get(key))
+            if full_parts:
+                break
+        if not full_parts:
+            full_parts = _semantic_hierarchy_parts(node) + ([feature_name] if feature_name else [])
+        if full_parts:
+            semantic_link_by_path.setdefault(" / ".join(full_parts), link_id)
+
     semantic_path_ids_by_link: dict[str, list[str]] = {}
     for node in semantic_nodes:
         link_id = str(node.get("link_id") or _node_link_id("rpg", node.get("node_id")))
@@ -685,7 +773,8 @@ def remember_path(alias: Any, path_ids: list[str]) -> None:
         path_ids: list[str] = ["focused-graph-root"]
         for part in _semantic_hierarchy_parts(node):
             trail.append(part)
-            path_ids.append(_node_link_id("feature-path", "/".join(trail)))
+            group_path = " / ".join(trail)
+            path_ids.append(semantic_link_by_path.get(group_path) or _node_link_id("feature-path", "/".join(trail)))
         path_ids.append(link_id)
         semantic_path_ids_by_link[link_id] = path_ids
         remember_path(link_id, path_ids)
diff --git a/CoderMind/tests/test_rpg_edit_run_report.py b/CoderMind/tests/test_rpg_edit_run_report.py
index a9e0f5b..b2d3677 100644
--- a/CoderMind/tests/test_rpg_edit_run_report.py
+++ b/CoderMind/tests/test_rpg_edit_run_report.py
@@ -49,6 +49,57 @@ def test_code_result_is_persisted(tmp_path: Path, monkeypatch) -> None:
     assert data == {"success": True, "commit_sha": "abc123"}
 
 
+def test_focused_graph_merges_semantic_group_container() -> None:
+    review = _load_script("rpg_edit_review_hierarchy_test", _SCRIPTS / "rpg_edit" / "review.py")
+    semantic_nodes = [
+        {
+            "node_id": "review edit impact_a8151bb7",
+            "link_id": "rpg-review-edit-impact_a8151bb7",
+            "name": "verify change impact",
+            "type": "feature_group",
+            "node_type": "feature_group",
+            "feature_path": "CoderMind / GraphNavigationAndEditing / analyze edit impact / assess change scope / verify change impact",
+            "state": "mapped",
+        },
+        {
+            "node_id": "collect review suggestions_2e3ac816",
+            "link_id": "rpg-collect-review-suggestions_2e3ac816",
+            "name": "publish embedded adaptive focused graph report",
+            "type": "feature",
+            "feature_path": "CoderMind / GraphNavigationAndEditing / analyze edit impact / assess change scope / verify change impact / publish embedded adaptive focused graph report",
+            "state": "mapped",
+            "changed_files": [{"path": "scripts/rpg_edit/review.py", "diff_anchor": "diff-review"}],
+        },
+    ]
+
+    hierarchy = review._focused_graph_hierarchy(semantic_nodes, [], [], [], {}, [])
+    rows = []
+
+    def walk(row):
+        if isinstance(row, dict):
+            rows.append(row)
+            for child in row.get("children") or []:
+                walk(child)
+
+    walk(hierarchy)
+    verify_nodes = [row for row in rows if row.get("name") == "verify change impact"]
+    old_placeholder = review._node_link_id(
+        "feature-path",
+        "CoderMind / GraphNavigationAndEditing / analyze edit impact / assess change scope / verify change impact",
+    )
+
+    assert len(verify_nodes) == 1
+    assert verify_nodes[0]["id"] == "rpg-review-edit-impact_a8151bb7"
+    assert verify_nodes[0]["node_id"] == "review edit impact_a8151bb7"
+    assert verify_nodes[0]["kind"] == "feature_group"
+    assert any(child.get("id") == "rpg-collect-review-suggestions_2e3ac816" for child in verify_nodes[0]["children"])
+    assert old_placeholder not in {row.get("id") for row in rows}
+
+    default_focus = review._focused_graph_default_focus(semantic_nodes, [], [], [], [])
+    assert "rpg-review-edit-impact_a8151bb7" in default_focus["focused_path_node_ids"]
+    assert old_placeholder not in default_focus["focused_path_node_ids"]
+
+
 def test_apply_result_preserves_rpg_metadata_when_dep_refresh_reuses_backup_ts(tmp_path: Path, monkeypatch) -> None:
     apply = _load_script("rpg_edit_apply_persist_test", _SCRIPTS / "rpg_edit" / "apply.py")
 
@@ -697,7 +748,7 @@ def fake_write_command_report(run):
         assert nodes_view["caps"] == {"primary_rpg_nodes": 20, "primary_code_nodes": 50, "edges": 80}
         assert nodes_view["graph_context"]["current_graph_available"] is True
         assert nodes_view["graph_context"]["current_rpg_nodes"] == 2
-        assert nodes_view["graph_context"]["current_dep_nodes"] == 2
+        assert nodes_view["graph_context"]["current_dep_nodes"] == 3
         assert focused["apply"]["status"] == "dep_refreshed"
         return report_path