@easysociable/cli 0.1.1 → 0.1.2

package/skills/easysociable-content/workbench/build.py

@@ -0,0 +1,1074 @@
+#!/usr/bin/env python3
+"""Scan Content Engine indexes → workbench/index.html (read-only)."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+OUT = Path(__file__).resolve().parent / "index.html"
+TPL = Path(__file__).resolve().parent / "template.html"
+
+PILLAR_HEAD = re.compile(r"^###\s+(P\d+)\s+[—–-]\s+(.+)$", re.M)
+# Known Chinese titles keyed by English heading from pillars.md (profile-agnostic fallbacks by P-id still OK for current vault).
+PILLAR_ZH_BY_EN = {
+    "Agency content problems": "机构内容生产问题",
+    "AI content systems": "AI 内容系统",
+    "Building EasySociable": "建造 EasySociable",
+}
+PILLAR_ZH_BY_ID = {
+    "P1": "机构内容生产问题",
+    "P2": "AI 内容系统",
+    "P3": "建造 EasySociable",
+}
+CAPTURE_RE = re.compile(r"C-\d{8}-\d{2}")
+SWIPE_RE = re.compile(r"\bS\d+\b")
+ATOM_RE = re.compile(r"\bA-[a-z0-9-]+\b")
+CLAIM_RE = re.compile(r"\bC-(?!\d{8})[a-z0-9-]+\b")
+RUN_RE = re.compile(r"RUN-[A-Za-z0-9-]+")
+WIKI = re.compile(r"\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]")
+
+
+def parse_pillars_file(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    out = {}
+    for m in PILLAR_HEAD.finditer(path.read_text(encoding="utf-8")):
+        pid, title = m.group(1), m.group(2)
+        title = re.sub(r"\s*\([^)]*\)\s*$", "", title).strip()
+        out[pid] = {
+            "en": title,
+            "zh": PILLAR_ZH_BY_EN.get(title) or PILLAR_ZH_BY_ID.get(pid, title),
+        }
+    return out
+
+
+def parse_registry() -> tuple[list[dict], list[dict], dict]:
+    """profiles, accounts, pillars_by_profile."""
+    profiles = []
+    for row in table_with(read("profiles/_index.md"), "id", "path", "voice", "one_liner", "accounts"):
+        if not row["id"] or row["id"].startswith("---"):
+            continue
+        path = row["path"].strip().strip("`") or f"profiles/{row['id']}/"
+        if not path.endswith("/"):
+            path = f"{path}/"
+        voice = row["voice"].strip().strip("`")
+        voice = re.split(r"\s*\(", voice, 1)[0].strip().strip("`")
+        profiles.append(
+            {
+                "id": row["id"],
+                "path": path,
+                "voice": voice,
+                "one_liner": row["one_liner"],
+                "accounts": [a.strip() for a in row["accounts"].split(",") if a.strip()],
+            }
+        )
+
+    accounts = []
+    for row in table_with(
+        read("accounts/_index.md"),
+        "handle",
+        "profile_id",
+        "voice",
+        "platforms",
+        "default_platform",
+        "overrides",
+        "status",
+    ):
+        if not row["handle"] or row["handle"].startswith("---"):
+            continue
+        accounts.append(
+            {
+                "handle": row["handle"],
+                "profile_id": row["profile_id"],
+                "voice": row["voice"],
+                "platforms": row["platforms"],
+                "default_platform": row["default_platform"],
+                "overrides": row["overrides"],
+                "status": row["status"],
+            }
+        )
+
+    pillars_by_profile = {}
+    for p in profiles:
+        pillars_by_profile[p["id"]] = parse_pillars_file(ROOT / p["path"] / "pillars.md")
+    return profiles, accounts, pillars_by_profile
+
+
+def read(rel: str) -> str:
+    return (ROOT / rel).read_text(encoding="utf-8")
+
+
+def extract_tables(md: str) -> list[dict]:
+    blocks: list[list[str]] = []
+    cur: list[str] = []
+    for line in md.splitlines():
+        if line.strip().startswith("|"):
+            cur.append(line)
+        elif cur:
+            blocks.append(cur)
+            cur = []
+    if cur:
+        blocks.append(cur)
+    tables = []
+    for block in blocks:
+        rows = []
+        for line in block:
+            raw = line.replace("\\|", "\x1e")
+            cells = [c.replace("\x1e", "|").strip() for c in raw.strip().strip("|").split("|")]
+            rows.append(cells)
+        if len(rows) < 2:
+            continue
+        headers = [h.strip() for h in rows[0]]
+        if all(set(h) <= set("-: ") for h in rows[1]):
+            body = rows[2:]
+        else:
+            body = rows[1:]
+        recs = []
+        for row in body:
+            if not any(row):
+                continue
+            rec = {}
+            for i, h in enumerate(headers):
+                rec[h] = row[i].strip() if i < len(row) else ""
+            recs.append(rec)
+        tables.append({"headers": headers, "rows": recs})
+    return tables
+
+
+def table_with(md: str, *need: str) -> list[dict]:
+    need_l = [n.lower() for n in need]
+    for t in extract_tables(md):
+        hs = [h.lower() for h in t["headers"]]
+        if all(n in hs for n in need_l):
+            key = {h.lower(): h for h in t["headers"]}
+            out = []
+            for row in t["rows"]:
+                out.append({n: row.get(key[n], "") for n in need_l})
+            return out
+    return []
+
+
+def hit_int(row: dict, key: str) -> int:
+    try:
+        return int(str(row.get(key, "") or "0").strip() or 0)
+    except ValueError:
+        return 0
+
+
+HTTP_RE = re.compile(r"https?://[^\s\]\)>'\"|]+")
+
+
+def wiki_path(cell: str) -> str:
+    m = WIKI.search(cell or "")
+    if not m:
+        return ""
+    p = m.group(1).strip()
+    if p.endswith(".md"):
+        return p
+    return p
+
+
+def run_folder_from_cell(cell: str) -> str:
+    p = wiki_path(cell)
+    parts = [x for x in p.replace("\\", "/").split("/") if x]
+    if len(parts) >= 2 and parts[0] == "runs":
+        return parts[1]
+    return ""
+
+
+def frontmatter(text: str) -> dict[str, str]:
+    if not text.startswith("---"):
+        return {}
+    end = text.find("\n---", 3)
+    if end < 0:
+        return {}
+    meta = {}
+    for line in text[4:end].splitlines():
+        if ":" not in line:
+            continue
+        k, v = line.split(":", 1)
+        meta[k.strip()] = v.strip().strip("\"'")
+    return meta
+
+
+def parse_library(cell: str) -> list[tuple[str, str]]:
+    if not cell or cell.strip() in ("none", "—", "-"):
+        return []
+    out = []
+    for part in cell.split(";"):
+        part = part.strip()
+        if ":" not in part:
+            continue
+        kind, rest = part.split(":", 1)
+        kind = kind.strip().lower()
+        kind = {"atoms": "atom", "claims": "claim", "swipes": "swipe"}.get(kind, kind)
+        for tok in rest.split(","):
+            tok = tok.strip()
+            if tok:
+                out.append((kind, tok))
+    return out
+
+
+def nid(kind: str, ident: str) -> str:
+    return f"{kind}:{ident}"
+
+
+def vault_file(path: str) -> str:
+    path = path.replace("\\", "/").lstrip("/")
+    if path and not path.endswith(".md") and "." not in Path(path).name:
+        # folder wiki → idea.md if run folder
+        pass
+    return f"Content Engine/{path}"
+
+
+def obsidian_uri(engine_rel: str) -> str:
+    file_enc = vault_file(engine_rel).replace(" ", "%20")
+    return f"obsidian://open?vault=Obsidian%20Vault&file={file_enc}"
+
+
+def node(
+    kind: str,
+    ident: str,
+    label: str,
+    path: str,
+    extra: dict,
+) -> dict:
+    d = {
+        "id": nid(kind, ident),
+        "kind": kind,
+        "ident": ident,
+        "label": label,
+        "path": path,
+        "obsidian": obsidian_uri(path) if path else "",
+        **extra,
+    }
+    return d
+
+
+def ids_in(text: str) -> dict[str, list[str]]:
+    return {
+        "capture": sorted(set(CAPTURE_RE.findall(text or ""))),
+        "swipe": sorted(set(SWIPE_RE.findall(text or ""))),
+        "atom": sorted(set(ATOM_RE.findall(text or ""))),
+        "claim": sorted(set(CLAIM_RE.findall(text or ""))),
+        "run": sorted(set(RUN_RE.findall(text or ""))),
+    }
+
+
+def field_ids(val: str, kind: str) -> list[str]:
+    v = (val or "").strip()
+    if not v or v.lower() == "none":
+        return []
+    return ids_in(v).get(kind, [])
+
+
+STAGE_NAMES = (
+    "idea",
+    "brief",
+    "packet",
+    "draft",
+    "editor",
+    "rubric",
+    "pack",
+    "feedback",
+)
+
+
+def run_stage_files(folder: Path, folder_name: str) -> dict[str, str]:
+    """Stage name → vault-relative .md path (only files that exist)."""
+    base = f"runs/{folder_name}"
+    out: dict[str, str] = {}
+    for name in STAGE_NAMES:
+        p = folder / f"{name}.md"
+        if p.exists():
+            out[name] = f"{base}/{name}.md"
+    if "pack" not in out:
+        packs = sorted(folder.glob("pack-*.md"))
+        if packs:
+            out["pack"] = f"{base}/{packs[0].name}"
+    return out
+
+
+def parse_feedback_metrics(text: str) -> dict:
+    out = {"has_numbers": False, "result": ""}
+    fm = frontmatter(text)
+    if fm.get("result"):
+        out["result"] = fm["result"]
+    if re.search(r"(views|likes|replies|bookmarks)\s*:", text, re.I):
+        out["has_numbers"] = True
+    return out
+
+
+ENGAGEMENT_SNAP_RE = re.compile(
+    r"engagement\s+snapshot:\s*(.+?)(?:\n|$)",
+    re.I,
+)
+ENGAGEMENT_PART_RE = re.compile(
+    r"(likes|replies|bookmarks|views)\s+(\d[\d,]*)",
+    re.I,
+)
+ENGAGEMENT_AT_RE = re.compile(r"@\s*(\d{4}-\d{2}-\d{2})")
+
+
+def parse_engagement_snapshot(text: str) -> dict[str, str]:
+    """Parse Discovery `engagement snapshot` line into src_* fields.
+
+    Only the primary snapshot counts. Parenthetical notes like
+    `(quoted earlier demo: likes 67 / bookmarks 115)` are ignored.
+    """
+    out = {
+        "src_likes": "",
+        "src_replies": "",
+        "src_bookmarks": "",
+        "src_views": "",
+        "engagement_at": "",
+    }
+    if not text:
+        return out
+    m = ENGAGEMENT_SNAP_RE.search(text)
+    if not m:
+        return out
+    # Keep only the primary snapshot; drop parenthetical secondary demos.
+    blob = m.group(1).split("(", 1)[0]
+    for kind, num in ENGAGEMENT_PART_RE.findall(blob):
+        key = f"src_{kind.lower()}"
+        # First occurrence wins (do not let later noise overwrite).
+        if key in out and not out[key]:
+            out[key] = num.replace(",", "")
+    at = ENGAGEMENT_AT_RE.search(blob)
+    if at:
+        out["engagement_at"] = at.group(1)
+    return out
+
+def build_graph() -> dict:
+    nodes: dict[str, dict] = {}
+    edges: list[dict] = []
+    profiles, accounts, pillars_by_profile = parse_registry()
+
+    def add_node(n: dict) -> None:
+        nodes[n["id"]] = n
+
+    def edge(a: str, b: str, rel: str) -> None:
+        if a in nodes and b in nodes:
+            edges.append({"from": a, "to": b, "rel": rel})
+
+    for p in profiles:
+        base = p["path"].rstrip("/") + "/"
+        files = {}
+        for name in ("README", "voice", "audience", "pillars"):
+            rel = f"{base}{name}.md"
+            if (ROOT / rel).exists():
+                files[name.lower()] = rel
+        readme = files.get("readme") or files.get("pillars") or f"{base}pillars.md"
+        add_node(
+            node(
+                "profile",
+                p["id"],
+                p["one_liner"] or p["id"],
+                readme,
+                {
+                    "one_liner": p["one_liner"],
+                    "voice": p["voice"],
+                    "accounts": p["accounts"],
+                    "pillar_ids": list(pillars_by_profile.get(p["id"], {}).keys()),
+                    "files": files,
+                    "dir": base,
+                },
+            )
+        )
+    for a in accounts:
+        add_node(
+            node(
+                "account",
+                a["handle"],
+                a["handle"],
+                "accounts/_index.md",
+                {
+                    "profile_id": a["profile_id"],
+                    "platforms": a["platforms"],
+                    "default_platform": a["default_platform"],
+                    "status": a["status"],
+                    "voice": a["voice"],
+                    "overrides": a["overrides"],
+                },
+            )
+        )
+        if a["profile_id"]:
+            edges.append(
+                {"from": nid("account", a["handle"]), "to": nid("profile", a["profile_id"]), "rel": "uses_profile"}
+            )
+
+    for row in table_with(read("inbox/_index.md"), "id", "date", "type", "one_liner", "platforms", "profile", "entry", "raw", "library", "status"):
+        ident = row["id"]
+        if not ident.startswith("C-"):
+            continue
+        entry = wiki_path(row["entry"]) or f"inbox/entries/{ident}"
+        if not entry.endswith(".md"):
+            entry = f"{entry}.md"
+        raw_path = wiki_path(row["raw"])
+        add_node(
+            node(
+                "capture",
+                ident,
+                row["one_liner"],
+                entry,
+                {
+                    "date": row["date"],
+                    "type": row["type"],
+                    "platforms": row["platforms"],
+                    "profile": row["profile"],
+                    "status": row["status"],
+                    "library_cell": row["library"],
+                    "raw_path": raw_path,
+                    "has_raw": bool(raw_path),
+                    "ingested": row["status"] == "ingested",
+                },
+            )
+        )
+        for kind, lib_id in parse_library(row["library"]):
+            edges.append({"from": nid("capture", ident), "to": nid(kind, lib_id), "rel": "ingested_as"})
+
+    for row in table_with(read("raw/_index.md"), "id", "date", "capture_id", "file", "type", "source_url", "one_liner"):
+        ident = row["id"]
+        fpath = wiki_path(row["file"])
+        if fpath and not fpath.endswith(".md"):
+            fpath = f"{fpath}.md"
+        add_node(
+            node(
+                "raw",
+                ident,
+                row["one_liner"],
+                fpath,
+                {
+                    "date": row["date"],
+                    "type": row["type"],
+                    "source_url": row["source_url"],
+                    "capture_id": row["capture_id"],
+                },
+            )
+        )
+        if row["capture_id"]:
+            edge(nid("capture", row["capture_id"]), nid("raw", ident), "has_raw")
+
+    discovery_md = read("discovery/_index.md")
+    # Current minimal schema. Legacy rows may still carry relevance/ownership/candidates.
+    discovery_rows = table_with(
+        discovery_md,
+        "id",
+        "date",
+        "profile",
+        "platform",
+        "source_handle",
+        "source_url",
+        "source_claim",
+        "source_role",
+        "status",
+        "next_action",
+        "topic_ids",
+        "file",
+    )
+    if not discovery_rows:
+        discovery_rows = table_with(
+            discovery_md,
+            "id",
+            "date",
+            "profile",
+            "platform",
+            "source_handle",
+            "source_url",
+            "source_claim",
+            "source_role",
+            "relevance",
+            "ownership",
+            "product_relevance",
+            "status",
+            "next_action",
+            "candidates",
+            "topic_ids",
+            "file",
+        )
+    for row in discovery_rows:
+        ident = row["id"]
+        if not ident.startswith("D-"):
+            continue
+        fpath = wiki_path(row["file"])
+        if fpath and not fpath.endswith(".md"):
+            fpath = f"{fpath}.md"
+        topic_ids = (row.get("topic_ids") or "").strip()
+        eng = parse_engagement_snapshot(read(fpath) if fpath and (ROOT / fpath).exists() else "")
+        add_node(
+            node(
+                "discovery",
+                ident,
+                row["source_claim"] or f"Discovery {ident}",
+                fpath,
+                {
+                    "date": row["date"],
+                    "profile": row["profile"],
+                    "platform": row["platform"],
+                    "source_handle": row["source_handle"],
+                    "source_url": row["source_url"],
+                    "source_claim": row["source_claim"],
+                    "source_role": row["source_role"],
+                    "relevance": row.get("relevance", "") or "",
+                    "ownership": row.get("ownership", "") or "",
+                    "product_relevance": row.get("product_relevance", "") or "",
+                    "status": row["status"],
+                    "next_action": row.get("next_action", "") or "",
+                    "candidates": row.get("candidates", "") or "",
+                    "topic_ids": topic_ids,
+                    **eng,
+                },
+            )
+        )
+        linked = re.findall(r"\bT-\d{8}-\d{2}\b", f"{topic_ids} {row.get('candidates') or ''}")
+        for tid in linked:
+            edge(nid("discovery", ident), nid("topic", tid), "candidate")
+
+    topic_md = read("topics/_index.md")
+    # Current: opp + aud (5C opportunity). Legacy: craft + fit, then single total.
+    topic_rows = table_with(
+        topic_md,
+        "id",
+        "date",
+        "opp",
+        "aud",
+        "status",
+        "purpose",
+        "scout",
+        "platform",
+        "pillar",
+        "one_liner",
+        "item",
+        "source_type",
+        "src_url",
+        "src_handle",
+        "src_likes",
+        "src_replies",
+        "src_bookmarks",
+        "engagement_at",
+        "capture_id",
+        "run",
+    )
+    if topic_rows:
+        topic_rows = [
+            {
+                **row,
+                "craft": row.get("opp", "") or "",
+                "fit": row.get("aud", "") or "",
+            }
+            for row in topic_rows
+        ]
+    if not topic_rows:
+        topic_rows = table_with(
+            topic_md,
+            "id",
+            "date",
+            "craft",
+            "fit",
+            "status",
+            "purpose",
+            "scout",
+            "platform",
+            "pillar",
+            "one_liner",
+            "item",
+            "source_type",
+            "src_url",
+            "src_handle",
+            "src_likes",
+            "src_replies",
+            "src_bookmarks",
+            "engagement_at",
+            "capture_id",
+            "run",
+        )
+    if not topic_rows:
+        topic_rows = [
+            {
+                **row,
+                "craft": row["total"],
+                "fit": "",
+                "purpose": "",
+                "scout": "",
+            }
+            for row in table_with(
+                topic_md,
+                "id",
+                "date",
+                "total",
+                "status",
+                "platform",
+                "pillar",
+                "one_liner",
+                "item",
+                "source_type",
+                "src_url",
+                "src_handle",
+                "src_likes",
+                "src_replies",
+                "src_bookmarks",
+                "engagement_at",
+                "capture_id",
+                "run",
+            )
+        ]
+
+    for row in topic_rows:
+        ident = row["id"]
+        if not ident.startswith("T-"):
+            continue
+        item = wiki_path(row["item"])
+        if item and not item.endswith(".md"):
+            item = f"{item}.md"
+        usage = "killed" if row["status"] == "killed" else ("promoted" if row["run"].strip() else "unused")
+        craft = row.get("craft", "") or ""
+        fit = row.get("fit", "") or ""
+        # Sort key: opp (aliased as craft) / legacy total
+        total = craft or row.get("total", "") or ""
+        profile = ""
+        if item and (ROOT / item).exists():
+            fm = re.match(r"^---\n(.*?)\n---", read(item), re.S)
+            if fm:
+                mprof = re.search(r"^profile:\s*(\S+)", fm.group(1), re.M)
+                if mprof:
+                    profile = mprof.group(1).strip()
+        add_node(
+            node(
+                "topic",
+                ident,
+                row["one_liner"],
+                item,
+                {
+                    "date": row["date"],
+                    "total": total,
+                    "opp": craft,
+                    "aud": fit,
+                    "craft": craft,
+                    "fit": fit,
+                    "purpose": row.get("purpose", "") or "",
+                    "scout": row.get("scout", "") or "",
+                    "status": row["status"],
+                    "platform": row["platform"],
+                    "pillar": row["pillar"],
+                    "profile": profile,
+                    "source_type": row["source_type"],
+                    "src_url": row["src_url"],
+                    "src_handle": row["src_handle"],
+                    "src_likes": row["src_likes"],
+                    "src_replies": row["src_replies"],
+                    "src_bookmarks": row["src_bookmarks"],
+                    "engagement_at": row["engagement_at"],
+                    "capture_id": row["capture_id"],
+                    "run_id": row["run"].strip(),
+                    "usage": usage,
+                    "src_heat_note": "来源帖热度，不是你的帖",
+                },
+            )
+        )
+        if row["capture_id"]:
+            edge(nid("topic", ident), nid("capture", row["capture_id"]), "from_capture")
+        if row["run"].strip().startswith("RUN-"):
+            edge(nid("topic", ident), nid("run", row["run"].strip()), "opened_run")
+        if item and (ROOT / item).exists():
+            body = read(item)
+            chunk = body
+            m = re.search(r"^## Suggested production.*?(?=^## |\Z)", body, re.M | re.S)
+            if m:
+                chunk = m.group(0)
+            for line in chunk.splitlines():
+                if ":" not in line:
+                    continue
+                key, rest = line.split(":", 1)
+                key, rest = key.strip().lower(), rest.strip()
+                if rest.lower().startswith("none"):
+                    continue
+                if "swipe" in key:
+                    for sid in ids_in(rest)["swipe"]:
+                        edges.append({"from": nid("topic", ident), "to": nid("swipe", sid), "rel": "suggested"})
+                elif "atom" in key:
+                    for aid in ids_in(rest)["atom"]:
+                        edges.append({"from": nid("topic", ident), "to": nid("atom", aid), "rel": "suggested"})
+                elif "claim" in key:
+                    for cid in ids_in(rest)["claim"]:
+                        edges.append({"from": nid("topic", ident), "to": nid("claim", cid), "rel": "suggested"})
+
+    for row in table_with(
+        read("swipe/_index.md"),
+        "id",
+        "file",
+        "platforms",
+        "profiles",
+        "form",
+        "beats_or_pages",
+        "status",
+        "n",
+        "win",
+        "loss",
+        "one_liner",
+        "source",
+    ):
+        ident = row["id"]
+        fpath = row["file"]
+        if fpath and not fpath.startswith("swipe/"):
+            fpath = f"swipe/{fpath}"
+        if fpath and not fpath.endswith(".md"):
+            fpath = f"{fpath}.md"
+        add_node(
+            node(
+                "swipe",
+                ident,
+                row["one_liner"],
+                fpath,
+                {
+                    "platforms": row["platforms"],
+                    "profiles": row["profiles"],
+                    "form": row["form"],
+                    "beats": row["beats_or_pages"],
+                    "status": row["status"],
+                    "n": hit_int(row, "n"),
+                    "win": hit_int(row, "win"),
+                    "loss": hit_int(row, "loss"),
+                    "source_cell": row["source"],
+                    "lib": True,
+                },
+            )
+        )
+        for cid in CAPTURE_RE.findall(row["source"]):
+            edge(nid("swipe", ident), nid("capture", cid), "sourced_from")
+
+    for row in table_with(
+        read("wiki/atoms/_index.md"),
+        "id",
+        "file",
+        "type",
+        "platforms",
+        "profiles",
+        "status",
+        "n",
+        "win",
+        "loss",
+        "one_liner",
+    ):
+        ident = row["id"]
+        fpath = row["file"]
+        if fpath and not fpath.startswith("wiki/"):
+            fpath = f"wiki/atoms/{fpath}"
+        if fpath and not fpath.endswith(".md"):
+            fpath = f"{fpath}.md"
+        add_node(
+            node(
+                "atom",
+                ident,
+                row["one_liner"],
+                fpath,
+                {
+                    "atom_type": row["type"],
+                    "platforms": row["platforms"],
+                    "profiles": row["profiles"],
+                    "status": row["status"],
+                    "n": hit_int(row, "n"),
+                    "win": hit_int(row, "win"),
+                    "loss": hit_int(row, "loss"),
+                    "lib": True,
+                },
+            )
+        )
+        if (ROOT / fpath).exists():
+            for cid in CAPTURE_RE.findall(read(fpath)):
+                edge(nid("atom", ident), nid("capture", cid), "sourced_from")
+
+    for row in table_with(
+        read("wiki/claims/_index.md"),
+        "id",
+        "file",
+        "type",
+        "platforms",
+        "profiles",
+        "status",
+        "n",
+        "win",
+        "loss",
+        "one_liner",
+    ):
+        ident = row["id"]
+        fpath = row["file"]
+        if fpath and not fpath.startswith("wiki/"):
+            fpath = f"wiki/claims/{fpath}"
+        if fpath and not fpath.endswith(".md"):
+            fpath = f"{fpath}.md"
+        evidence_runs = []
+        if (ROOT / fpath).exists():
+            body = read(fpath)
+            for cid in CAPTURE_RE.findall(body):
+                edge(nid("claim", ident), nid("capture", cid), "sourced_from")
+            in_ev = False
+            for line in body.splitlines():
+                if line.startswith("## Evidence"):
+                    in_ev = True
+                    continue
+                if in_ev and line.startswith("## "):
+                    break
+                if in_ev:
+                    evidence_runs += RUN_RE.findall(line)
+        add_node(
+            node(
+                "claim",
+                ident,
+                row["one_liner"],
+                fpath,
+                {
+                    "claim_type": row["type"],
+                    "platforms": row["platforms"],
+                    "profiles": row["profiles"],
+                    "status": row["status"],
+                    "n": hit_int(row, "n"),
+                    "win": hit_int(row, "win"),
+                    "loss": hit_int(row, "loss"),
+                    "evidence_runs": evidence_runs,
+                    "has_evidence": bool(evidence_runs),
+                    "lib": True,
+                },
+            )
+        )
+
+    for row in table_with(
+        read("runs/_index.md"),
+        "run_id",
+        "path",
+        "date",
+        "status",
+        "account",
+        "profile",
+        "primary_platform",
+        "platforms",
+        "topic_id",
+        "pillar",
+        "one_liner",
+        "pack",
+        "export",
+        "notes",
+    ):
+        ident = row["run_id"]
+        if not ident.startswith("RUN-"):
+            continue
+        folder_wiki = wiki_path(row["path"])
+        folder = folder_wiki.replace("runs/", "").strip("/")
+        rdir = ROOT / "runs" / folder if folder else None
+        stage_files = run_stage_files(rdir, folder) if rdir and rdir.is_dir() and folder else {}
+        stages = {n: n in stage_files for n in STAGE_NAMES}
+        idea_path = stage_files.get("idea") or (f"runs/{folder}/idea.md" if folder else "")
+        selection = {"swipe": "none", "atoms": "none", "claim": "none"}
+        supersedes = ""
+        superseded_by = ""
+        capture_ids = []
+        if idea_path and (ROOT / idea_path).exists():
+            idea = read(idea_path)
+            fm = frontmatter(idea)
+            supersedes = fm.get("supersedes", "")
+            superseded_by = fm.get("superseded_by", "")
+            for line in idea.splitlines():
+                if "swipe_id" in line:
+                    selection["swipe"] = line.split(":", 1)[-1].strip().lstrip("- ").replace("**swipe_id:**", "").strip()
+                if "**atoms:**" in line or line.strip().startswith("- **atoms:**"):
+                    selection["atoms"] = line.split(":", 1)[-1].strip().lstrip("- ").replace("**atoms:**", "").strip()
+                if "hypothesis" in line and "swipe_why" not in line:
+                    selection["claim"] = line.split(":", 1)[-1].strip().lstrip("- ").replace("**hypothesis:**", "").strip()
+                if "claim_id" in line:
+                    selection["claim"] = line.split(":", 1)[-1].strip().lstrip("- ").replace("**claim_id:**", "").strip()
+                if "capture_ids" in line:
+                    capture_ids = CAPTURE_RE.findall(line)
+            sm = re.search(r"\*\*swipe_id:\*\*\s*(\S+)", idea)
+            if sm:
+                selection["swipe"] = sm.group(1)
+            am = re.search(r"\*\*atoms:\*\*\s*(.+)", idea)
+            if am:
+                selection["atoms"] = am.group(1).strip()
+            cm = re.search(r"\*\*(?:claim_id|hypothesis):\*\*\s*(\S+)", idea)
+            if cm:
+                selection["claim"] = cm.group(1)
+        metrics = {}
+        ship_urls = []
+        fb = rdir / "feedback.md" if rdir else None
+        if fb and fb.exists():
+            fb_text = fb.read_text(encoding="utf-8")
+            metrics = parse_feedback_metrics(fb_text)
+            ship_urls = [u.rstrip(".,;") for u in HTTP_RE.findall(fb_text)]
+        add_node(
+            node(
+                "run",
+                ident,
+                row["one_liner"],
+                f"runs/{folder}" if folder else "",
+                {
+                    "date": row["date"],
+                    "status": row["status"],
+                    "account": row["account"],
+                    "profile": row["profile"],
+                    "primary_platform": row["primary_platform"],
+                    "platforms": row["platforms"],
+                    "topic_id": row["topic_id"] if row["topic_id"] != "none" else "",
+                    "pillar": row["pillar"],
+                    "pack": row["pack"],
+                    "export": row["export"],
+                    "notes": row["notes"],
+                    "folder": folder,
+                    "stages": stages,
+                    "stage_files": stage_files,
+                    "selection": selection,
+                    "supersedes": supersedes,
+                    "superseded_by": superseded_by,
+                    "metrics": metrics,
+                    "ship_urls": ship_urls,
+                    "open_file": idea_path,
+                    "obsidian": obsidian_uri(idea_path) if idea_path else "",
+                },
+            )
+        )
+        if row["topic_id"] not in ("", "none"):
+            edge(nid("run", ident), nid("topic", row["topic_id"]), "from_topic")
+        for cid in capture_ids:
+            edge(nid("run", ident), nid("capture", cid), "from_capture")
+        for sid in field_ids(selection["swipe"], "swipe"):
+            edge(nid("run", ident), nid("swipe", sid), "uses")
+        for aid in field_ids(selection["atoms"], "atom"):
+            edge(nid("run", ident), nid("atom", aid), "uses")
+        for cid in field_ids(selection["claim"], "claim"):
+            edge(nid("run", ident), nid("claim", cid), "uses")
+        if supersedes.startswith("RUN-"):
+            edges.append({"from": nid("run", ident), "to": nid("run", supersedes), "rel": "supersedes"})
+
+    folder_to_run = {
+        n["folder"]: n["ident"] for n in nodes.values() if n["kind"] == "run" and n.get("folder")
+    }
+
+    for row in table_with(
+        read("published/_index.md"),
+        "date",
+        "platform",
+        "url",
+        "run",
+        "pillar",
+        "swipe",
+        "atoms",
+        "claim",
+        "result",
+        "notes",
+    ):
+        if not row["url"].startswith("http"):
+            continue
+        run_cell = row["run"]
+        run_folder = run_folder_from_cell(run_cell)
+        run_id = (RUN_RE.findall(run_cell) or [""])[0]
+        if not run_id and run_folder in folder_to_run:
+            run_id = folder_to_run[run_folder]
+        run_node = nodes.get(nid("run", run_id)) if run_id else None
+        profile = (run_node or {}).get("profile", "")
+        ident = f"{row['date']}-{row['platform']}-{run_id or 'unknown'}"
+        add_node(
+            node(
+                "published",
+                ident,
+                row["url"],
+                "",
+                {
+                    "date": row["date"],
+                    "platform": row["platform"],
+                    "url": row["url"],
+                    "run_id": run_id,
+                    "run_folder": run_folder,
+                    "profile": profile,
+                    "topic_id": (run_node or {}).get("topic_id", "") or "",
+                    "pillar": row["pillar"],
+                    "swipe": row["swipe"],
+                    "atoms": row["atoms"],
+                    "claim": row["claim"],
+                    "result": row["result"],
+                    "notes": row["notes"],
+                    "reviewable": row["result"] in ("win", "flat", "loss"),
+                    "obsidian": obsidian_uri("published/_index.md"),
+                    "path": "published/_index.md",
+                },
+            )
+        )
+        if run_id:
+            edge(nid("published", ident), nid("run", run_id), "from_run")
+        for sid in field_ids(row["swipe"], "swipe"):
+            edge(nid("published", ident), nid("swipe", sid), "uses")
+        for aid in field_ids(row["atoms"], "atom"):
+            edge(nid("published", ident), nid("atom", aid), "uses")
+        for cid in field_ids(row["claim"], "claim"):
+            edge(nid("published", ident), nid("claim", cid), "uses")
+
+    # Capture → surface source_url from linked Raw
+    for n in list(nodes.values()):
+        if n["kind"] != "capture":
+            continue
+        for e in edges:
+            if e["rel"] != "has_raw" or e["from"] != n["id"]:
+                continue
+            raw = nodes.get(e["to"])
+            if raw and raw.get("source_url"):
+                n["source_url"] = raw["source_url"]
+                n["raw_id"] = raw["ident"]
+                break
+
+    # drop edges to missing nodes
+    edges = [e for e in edges if e["from"] in nodes and e["to"] in nodes]
+    seen = set()
+    uniq = []
+    for e in edges:
+        k = (e["from"], e["to"], e["rel"])
+        if k not in seen:
+            seen.add(k)
+            uniq.append(e)
+
+    run_uses: dict[str, set[str]] = {}
+    for e in uniq:
+        if e["rel"] != "uses":
+            continue
+        src = nodes.get(e["from"])
+        dst = e["to"]
+        if not src:
+            continue
+        if src["kind"] == "run":
+            run_uses.setdefault(dst, set()).add(src["id"])
+        elif src["kind"] == "published":
+            run_uses.setdefault(dst, set()).add(nid("run", src["run_id"]) if src.get("run_id") else src["id"])
+    for n in nodes.values():
+        if n["kind"] in ("swipe", "atom", "claim"):
+            n["refs"] = len(run_uses.get(n["id"], ()))
+
+    # flat pillars: prefer first profile for legacy callers; JS uses pillars_by_profile
+    flat_pillars = {}
+    for pid in sorted(pillars_by_profile.keys()):
+        for k, v in pillars_by_profile[pid].items():
+            flat_pillars.setdefault(k, v)
+
+    return {
+        "generated_at": datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC"),
+        "vault": str(ROOT),
+        "profiles": profiles,
+        "accounts": accounts,
+        "pillars_by_profile": pillars_by_profile,
+        "pillars": flat_pillars,
+        "nodes": list(nodes.values()),
+        "edges": uniq,
+    }
+
+
+def main() -> None:
+    graph = build_graph()
+    html = TPL.read_text(encoding="utf-8")
+    payload = json.dumps(graph, ensure_ascii=False)
+    html = html.replace("/*__GRAPH__*/null", payload)
+    OUT.write_text(html, encoding="utf-8")
+    print(f"wrote {OUT} ({len(graph['nodes'])} nodes, {len(graph['edges'])} edges)")
+
+
+if __name__ == "__main__":
+    main()