raidlock 0.1.0__py3-none-any.whl

raidlock/web/raidmap/__init__.py

@@ -0,0 +1,205 @@
+"""Territory map: every locked path, grouped by repo, with its current holder and contention."""
+
+import os
+
+from raidlock.core import leases as L
+from raidlock.core.errors import Precondition
+from raidlock.core.paths import overlaps
+
+from ..replay import data_of, fold, records
+
+OPEN = ("todo", "doing", "review", "blocked")
+EVENTS = ("lock_violation", "lock_denied")
+EVENT_SCAN = 5000
+MAX_HISTORY_WORK = 100000
+
+
+def _relative(board, path):
+    if not path:
+        return ""
+    if not os.path.isabs(path):
+        return path.strip("/")
+    for root in (board.workspace, os.path.realpath(board.workspace)):
+        try:
+            rel = os.path.relpath(path, root)
+        except ValueError:
+            continue
+        if not rel.startswith(".."):
+            return rel.replace(os.sep, "/")
+    return ""
+
+
+def lock_events(board, until=None):
+    """Recorded lock denials and violations: [{seq, ts, event, agent, card, paths}], newest EVENT_SCAN status
+    records only."""
+    out = []
+    source = records(board, until) if until is not None else board.transcript.read(kind="status", limit=EVENT_SCAN)
+    for r in source[-EVENT_SCAN:]:
+        if until is not None and r["seq"] > until:
+            continue
+        data = data_of(r)
+        if data.get("event") not in EVENTS:
+            continue
+        raw = data.get("paths") or ([data.get("path")] if data.get("path") else [])
+        paths = [p for p in (_relative(board, x) for x in raw) if p]
+        out.append(
+            {
+                "seq": r["seq"],
+                "ts": r.get("ts", ""),
+                "event": data["event"],
+                "agent": data.get("agent") or (r.get("from") or {}).get("agent", ""),
+                "card": r.get("taskId", "") or "",
+                "paths": paths,
+            }
+        )
+    return out
+
+
+def _holders_now(board, cards):
+    out = []
+    for cid, lease in board.leases().items():
+        if not L.is_live(lease):
+            continue
+        card = cards.get(cid, {})
+        out.append(
+            {
+                "agent": lease.get("agent", ""),
+                "card": cid,
+                "lane": card.get("lane", ""),
+                "paths": lease.get("paths") or card.get("locks", []),
+                "expires": lease.get("expires"),
+            }
+        )
+    return out
+
+
+def territory(board, at=None, state=None):
+    cards = {c["id"]: c for c in board.cards()}
+    if at is None:
+        holders = _holders_now(board, cards)
+        lanes = {cid: c["lane"] for cid, c in cards.items()}
+    else:
+        state = state if state is not None else fold(board, at, marks=False)
+        cards = {c["id"]: c for c in state["cards"]}
+        holders = [dict(h, expires=None) for h in state["holders"]]
+        lanes = {c["id"]: c["lane"] for c in state["cards"]}
+    events = lock_events(board, until=at)
+    if at is not None:
+        path_count = sum(len(c.get("locks", [])) for c in cards.values())
+        comparisons = sum(len(h["paths"]) for h in holders) + sum(len(e["paths"]) for e in events)
+        if path_count * max(1, comparisons) > MAX_HISTORY_WORK:
+            return {
+                "at": at,
+                "trust": "unverified history",
+                "approximate": True,
+                "incomplete_history": True,
+                "error": "history work budget exceeded",
+                "repos": [],
+                "agents": [],
+                "held": 0,
+                "contested": 0,
+                "events": [],
+            }
+    held_cards = {h["card"] for h in holders}
+    paths = {}
+
+    def entry(path):
+        e = paths.get(path)
+        if e is None:
+            head, _, rest = path.partition("/")
+            e = paths[path] = {
+                "path": path,
+                "metadata_source": "current metadata" if at is not None else "live",
+                "repo": head,
+                "rest": rest,
+                "holder": "",
+                "card": "",
+                "lane": "",
+                "expires": None,
+                "cards": [],
+                "waiting": [],
+                "denials": 0,
+                "violations": 0,
+            }
+        return e
+
+    for h in holders:
+        for p in h["paths"]:
+            e = entry(p)
+            e.update(holder=h["agent"], card=h["card"], lane=h["lane"], expires=h["expires"])
+            if at is not None:
+                e["metadata_source"] = "unverified history"
+    for cid, c in sorted(cards.items()):
+        lane = lanes.get(cid)
+        if lane not in OPEN:
+            continue
+        for p in c.get("locks", []):
+            e = entry(p)
+            if cid not in e["cards"]:
+                e["cards"].append(cid)
+    for e in paths.values():
+        for cid in e["cards"]:
+            if cid in held_cards or lanes.get(cid) not in ("todo", "blocked"):
+                continue
+            for h in holders:
+                clash = h["card"] != cid and any(overlaps(e["path"], p) for p in h["paths"])
+                if clash and cid not in e["waiting"]:
+                    e["waiting"].append(cid)
+        for ev in events:
+            if any(overlaps(e["path"], p) for p in ev["paths"]):
+                e["violations" if ev["event"] == "lock_violation" else "denials"] += 1
+        e["contested"] = bool(e["waiting"] or e["denials"] or e["violations"])
+    repos = {}
+    for e in sorted(paths.values(), key=lambda x: x["path"]):
+        repos.setdefault(e["repo"], []).append(e)
+    agents = sorted({e["holder"] for e in paths.values() if e["holder"]})
+    return {
+        "at": at,
+        "trust": "unverified history" if at is not None else "live",
+        "approximate": at is not None,
+        "incomplete_history": bool(state and state["incomplete_history"]),
+        "repos": [
+            {
+                "name": name,
+                "paths": items,
+                "held": sum(1 for i in items if i["holder"]),
+                "contested": sum(1 for i in items if i["contested"]),
+            }
+            for name, items in sorted(repos.items())
+        ],
+        "agents": agents,
+        "held": sum(1 for e in paths.values() if e["holder"]),
+        "contested": sum(1 for e in paths.values() if e["contested"]),
+        "events": events[-50:],
+    }
+
+
+def payload(board, query):
+    raw = (query.get("at") or [""])[0]
+    try:
+        at = int(raw) if raw else None
+    except ValueError:
+        raise Precondition("at must be an integer") from None
+    if at is not None and at < 0:
+        raise Precondition("at must be a nonnegative transcript sequence number")
+    return territory(board, at)
+
+
+def _setup(parser):
+    parser.add_argument("--at", type=int, default=None, help="transcript sequence number (default: live leases)")
+
+
+def _handle(ctx, args):
+    result = territory(ctx.board, args.at)
+    lines = []
+    for repo in result["repos"]:
+        lines.append(f"{repo['name']}: {repo['held']} held, {repo['contested']} contested")
+        for e in repo["paths"]:
+            who = f"{e['holder']} on {e['card']}" if e["holder"] else "free"
+            flag = " CONTESTED" if e["contested"] else ""
+            lines.append(f"  {e['path']}: {who}{flag}")
+    return result, "\n".join(lines) or "No locked paths."
+
+
+def register_cli(add_command):
+    add_command("map", "territory map: which agent holds which locked paths, and where they clash", _setup, _handle)

raidlock/web/raidmap/view.css

@@ -0,0 +1,15 @@
+.view-head{display:flex;flex-wrap:wrap;gap:6px 12px;align-items:baseline}
+.view-head p{margin:0;flex:1 1 220px}
+.zones{display:flex;flex-direction:column;gap:12px}
+.repo-zone{background:var(--panel);border:1px solid var(--edge);border-radius:14px;padding:8px 10px 10px;min-width:0}
+.repo-zone h3{margin:0 0 8px;font-size:14px;color:var(--accent);overflow-wrap:anywhere}
+.tiles{display:flex;flex-wrap:wrap;gap:6px}
+.tile{flex:var(--w,1) 1 9rem;min-width:0;min-height:64px;display:flex;flex-direction:column;gap:3px;padding:6px 8px;border-radius:8px;border:1px solid var(--edge);border-left:6px solid var(--agc,var(--edge));background:color-mix(in srgb,var(--agc,var(--card2)) 22%,var(--card2));font-size:14px;overflow-wrap:anywhere}
+.tile.free{background:var(--card2);border-left-color:var(--edge);color:var(--muted)}
+.tile .p{color:var(--ink);font-size:14px}
+.tile .who{color:var(--muted)}
+.tile .lane-tag{align-self:flex-start;font-size:12px;border:1px solid var(--edge);border-radius:6px;padding:0 6px}
+.tile .flag{align-self:flex-start;font-size:12px;color:var(--blocked);font-weight:bold}
+.tile.contested{border-color:var(--blocked);background-image:repeating-linear-gradient(135deg,transparent 0 8px,color-mix(in srgb,var(--blocked) 18%,transparent) 8px 12px)}
+#viewPane .sw.free-sw{background:var(--card2);border:1px solid var(--edge)}
+#viewPane .sw.hatch{background:repeating-linear-gradient(135deg,var(--card2) 0 3px,var(--blocked) 3px 5px)}

raidlock/web/raidmap/view.js

@@ -0,0 +1,47 @@
+"use strict";
+(function () {
+  const views = window.RaidlockViews = window.RaidlockViews || [];
+  function tile(c, e) {
+    const held = !!e.holder;
+    const cls = ["tile", held ? c.agentClass(e.holder) : "free", e.contested ? "contested" : ""].filter(Boolean).join(" ");
+    const flags = [];
+    if (e.waiting.length) flags.push(c.h("span", {class: "flag", text: `${e.waiting.length} waiting: ${e.waiting.join(", ")}`}));
+    if (e.denials) flags.push(c.h("span", {class: "flag", text: `${e.denials} denied`}));
+    if (e.violations) flags.push(c.h("span", {class: "flag", text: `${e.violations} write ${e.violations === 1 ? "violation" : "violations"}`}));
+    const who = held ? `${e.holder} on ${e.card}` : (e.cards.length ? `free · ${e.cards.join(", ")}` : "free");
+    const label = `${e.path}${e.metadata_source ? " (" + e.metadata_source + ")" : ""}: ${who}${e.contested ? ", contested" : ""}`;
+    const el = c.h("div", {class: cls, "data-path": e.path, "data-holder": e.holder || "", title: label},
+      c.h("b", {class: "p", text: e.rest || e.path}),
+      c.h("span", {class: "who", text: who}),
+      e.lane && held ? c.h("span", {class: "lane-tag", text: e.lane}) : null,
+      flags);
+    el.classList.add("tile-weight-" + Math.min(10, 1 + e.cards.length + (held ? 1 : 0)));
+    return el;
+  }
+  function tiles(c, d) {
+    if (!(d.repos || []).length) return [c.h("div", {class: "empty", text: "No locked paths yet. A card's --locks paths show up here once the card exists."})];
+    return d.repos.map(r => c.h("div", {class: "repo-zone", "data-repo": r.name},
+      c.h("h3", null, r.name, c.h("span", {class: "cls", text: ` ${r.held} held · ${r.contested} contested · ${r.paths.length} ${r.paths.length === 1 ? "path" : "paths"}`})),
+      c.h("div", {class: "tiles"}, r.paths.map(e => tile(c, e)))));
+  }
+  function legend(c, d) {
+    return c.h("div", {class: "legend-row"},
+      (d.agents || []).map(a => c.h("span", {class: c.agentClass(a)}, c.h("i", {class: "sw"}), a)),
+      c.h("span", null, c.h("i", {class: "sw free-sw"}), "free"),
+      c.h("span", null, c.h("i", {class: "sw hatch"}), "contested: a waiting card overlaps a held path, or a lock denial or write violation was recorded on it"));
+  }
+  views.push({
+    id: "map",
+    endpoint: "raidmap",
+    label: {raid: "War map", plain: "Map"},
+    tiles, legend,
+    render(c, d, pane) {
+      const head = c.h("div", {class: "view-head"},
+        c.h("h2", null, c.raid ? "War map" : "Map", c.raid && c.raidSub ? c.raidSub("Map") : null),
+        c.h("p", {class: "cls", text: `Which agent holds which locked paths: ${d.held} held, ${d.contested} contested. Updates every few seconds.`}),
+        c.h("button", {type: "button", class: "tog", "data-go": "replay", text: c.raid ? "See how it changed in the Chronicle" : "See how it changed in Timeline"}));
+      head.querySelector("[data-go]").addEventListener("click", () => c.go("replay"));
+      c.setKids(pane, [head, legend(c, d), c.h("div", {class: "zones"}, tiles(c, d))], JSON.stringify([d, c.theme]));
+    }
+  });
+})();

raidlock/web/replay/__init__.py

@@ -0,0 +1,258 @@
+"""Rebuild board state at any transcript sequence number by folding the recorded events in order."""
+
+import math
+
+from raidlock.core.errors import Precondition
+from raidlock.core.transcript import KINDS
+
+LANES = ("todo", "doing", "review", "blocked", "done")
+HOLD = ("doing", "review", "blocked")
+PAGE = 5000
+MAX_RECORDS = 200000
+MARKS = 4000
+RECENT = 8
+
+
+def data_of(record):
+    out = {}
+    parts = list(record.get("parts", []))
+    for artifact in record.get("artifacts", []):
+        parts.extend(artifact.get("parts", []))
+    for part in parts:
+        if part.get("kind") == "data" and isinstance(part.get("data"), dict):
+            out.update(part["data"])
+    return out
+
+
+def text_of(record):
+    return "\n".join(p.get("text", "") for p in record.get("parts", []) if p.get("kind") == "text")
+
+
+MAX_BYTES = 16 * 1024 * 1024
+
+
+def history(board):
+    version = board.version()
+    cached = getattr(board, "_history_cache", None)
+    if cached and cached[0] == version:
+        return cached[1]
+    transcript = board.transcript
+    latest = transcript.index.query_transcript(transcript.ws, limit=1)
+    last = latest[-1]["seq"] if latest else 0
+    out, cursor, size = [], 0, 0
+    incomplete = False
+    while cursor < last:
+        rows = transcript.index.query_transcript(transcript.ws, since=cursor, limit=PAGE)
+        selected = []
+        for row in rows:
+            if len(out) + len(selected) >= MAX_RECORDS or size + row["length"] > MAX_BYTES:
+                incomplete = True
+                break
+            selected.append(row)
+            size += row["length"]
+        out.extend(transcript._load(selected))
+        if incomplete or not rows:
+            break
+        cursor = rows[-1]["seq"]
+    result = (out, last, incomplete)
+    board._history_cache = (version, result)
+    return result
+
+
+def records(board, until=None):
+    every, _, _ = history(board)
+    return [r for r in every if until is None or r["seq"] <= until]
+
+
+class State:
+    def __init__(self, titles):
+        self.titles = titles
+        self.cards = {}
+        self.locks = {}
+        self.non_core = False
+        self.events = {"lock_violation": 0, "lock_denied": 0, "stale_fence": 0}
+
+    def card(self, cid):
+        c = self.cards.get(cid)
+        if c is None:
+            c = self.cards[cid] = {
+                "id": cid,
+                "trust": "unverified history",
+                "title_source": "current metadata",
+                "lease_holder": "",
+                "title": self.titles.get(cid, cid),
+                "lane": "todo",
+                "owner": "",
+                "tokens": 0,
+                "usd_equiv": 0.0,
+                "notes": 0,
+                "since": "",
+            }
+        return c
+
+    def apply(self, r):
+        kind, task = r.get("kind"), r.get("taskId") or ""
+        if r.get("src") != "board" or kind not in KINDS:
+            self.non_core = True
+            return
+        sender = (r.get("from") or {}).get("agent", "")
+        text, data = text_of(r), data_of({"parts": r.get("parts", [])})
+        event = data.get("event")
+        if event in self.events:
+            self.events[event] += 1
+        if not task:
+            return
+        if kind == "status":
+            if text.startswith(f"created {task}:"):
+                c = self.card(task)
+                c["title"] = text.split(":", 1)[1].strip() or task
+                c["title_source"] = "unverified history"
+                if isinstance(data.get("locks"), list):
+                    self.locks[task] = data["locks"]
+                c.update(lane="todo", owner="", lease_holder="", since=r.get("ts", ""))
+            elif (
+                data.get("a2a_state") == "working"
+                and "fence" in data
+                and (text.startswith("claimed by ") or "taken over from" in text)
+            ):
+                self.card(task).update(lane="doing", owner=sender, lease_holder=sender, since=r.get("ts", ""))
+            elif data.get("lane") in LANES and text.startswith(f"{task} -> {data['lane']}"):
+                c = self.card(task)
+                c.update(lane=data["lane"], since=r.get("ts", ""))
+                if data["lane"] in ("todo", "done"):
+                    c["lease_holder"] = ""
+                if data["lane"] == "todo":
+                    c["owner"] = ""
+            elif text == "lease released":
+                c = self.card(task)
+                c["lease_holder"] = ""
+                if c["lane"] == "doing":
+                    c.update(lane="todo", owner="", lease_holder="", since=r.get("ts", ""))
+            elif data.get("a2a_state") == "submitted" and text.endswith("reopened"):
+                self.card(task).update(lane="todo", owner="", lease_holder="", since=r.get("ts", ""))
+            elif text == "lease expired; reaped to blocked":
+                self.card(task).update(lane="blocked", lease_holder="", since=r.get("ts", ""))
+            elif text == "lease resumed after expiry":
+                self.card(task)["lease_holder"] = sender
+            if (
+                (text.startswith(f"created {task}:") or text.startswith("claimed by ") or text == "locks updated")
+                and isinstance(data.get("locks"), list)
+                and all(isinstance(p, str) for p in data["locks"])
+            ):
+                self.locks[task] = data["locks"]
+        elif kind == "cost":
+            c = self.card(task)
+            c["tokens"] += int(data.get("tokens") or 0)
+            value = float(data.get("usd_equiv") or 0)
+            if math.isfinite(value):
+                c["usd_equiv"] = round(c["usd_equiv"] + value, 6)
+        elif kind == "note":
+            self.card(task)["notes"] += 1
+
+
+def mark(r):
+    text = text_of(r) or ", ".join(a.get("name", "") for a in r.get("artifacts", []))
+    return {
+        "seq": r["seq"],
+        "trust": "unverified history",
+        "source": r.get("src", "unknown"),
+        "ts": r.get("ts", ""),
+        "kind": r.get("kind", ""),
+        "task": r.get("taskId", "") or "",
+        "agent": (r.get("from") or {}).get("agent", ""),
+        "text": text[:160],
+    }
+
+
+def fold(board, at=None, marks=True):
+    """Board state right after transcript record `at` (default: the newest)."""
+    if at is not None and (not isinstance(at, int) or at < 0):
+        raise Precondition("at must be a nonnegative transcript sequence number")
+    current = {c["id"]: c for c in board.cards()}
+    every, latest, incomplete = history(board)
+    if not every:
+        return {
+            "at": 0,
+            "ts": "",
+            "first": 0,
+            "last": latest,
+            "incomplete_history": incomplete,
+            "trust": "unverified history",
+            "non_core_records": False,
+            "total": 0,
+            "marks": [],
+            "truncated": False,
+            "cards": [],
+            "counts": dict.fromkeys(LANES, 0),
+            "holders": [],
+            "recent": [],
+            "events": {},
+            "untracked": len(current),
+        }
+    last = every[-1]["seq"]
+    point = last if at is None else max(every[0]["seq"], min(at, last))
+    state = State({k: v.get("title", k) for k, v in current.items()})
+    upto = []
+    for r in every:
+        if r["seq"] > point:
+            break
+        state.apply(r)
+        upto.append(r)
+    lock_of = {k: v.get("locks", []) for k, v in current.items()}
+    cards = sorted(state.cards.values(), key=lambda c: (LANES.index(c["lane"]), c["id"]))
+    for c in cards:
+        c["locks"] = state.locks.get(c["id"], lock_of.get(c["id"], []))
+        c["locks_source"] = "unverified history" if c["id"] in state.locks else "current metadata"
+    holders = [
+        {"agent": c["lease_holder"], "card": c["id"], "lane": c["lane"], "paths": c["locks"]}
+        for c in cards
+        if c["lease_holder"] and c["id"] in state.locks
+    ]
+    shown = [mark(r) for r in every[-MARKS:]] if marks else []
+    return {
+        "at": point,
+        "ts": upto[-1].get("ts", "") if upto else "",
+        "first": every[0]["seq"],
+        "last": latest,
+        "incomplete_history": incomplete,
+        "trust": "unverified history",
+        "non_core_records": state.non_core,
+        "total": len(every),
+        "marks": shown,
+        "truncated": len(every) > MARKS,
+        "cards": cards,
+        "counts": {lane: sum(1 for c in cards if c["lane"] == lane) for lane in LANES},
+        "holders": holders,
+        "recent": [mark(r) for r in upto[-RECENT:]][::-1],
+        "events": dict(state.events),
+        "untracked": sum(1 for k in current if k not in state.cards),
+    }
+
+
+def payload(board, query):
+    raw = (query.get("at") or [""])[0]
+    try:
+        at = int(raw) if raw else None
+    except ValueError:
+        raise Precondition("at must be an integer") from None
+    from ..raidmap import territory
+
+    state = fold(board, at, marks=(query.get("marks") or ["1"])[0] != "0")
+    return {**state, "territory": territory(board, state["at"], state=state)}
+
+
+def _setup(parser):
+    parser.add_argument("--at", type=int, default=None, help="transcript sequence number (default: newest)")
+
+
+def _handle(ctx, args):
+    result = fold(ctx.board, args.at, marks=False)
+    lines = [f"at seq {result['at']} of {result['first']}..{result['last']} ({result['ts'] or 'empty'})"]
+    lines.append(", ".join(f"{n} {lane}" for lane, n in result["counts"].items()))
+    for c in result["cards"]:
+        lines.append(f"  {c['lane']:<8} {c['id']}" + (f" ({c['owner']})" if c["owner"] else ""))
+    return result, "\n".join(lines)
+
+
+def register_cli(add_command):
+    add_command("replay", "board state rebuilt from the transcript at a point in time", _setup, _handle)

raidlock/web/replay/view.css

@@ -0,0 +1,13 @@
+.rp-controls{display:flex;flex-wrap:wrap;gap:8px;align-items:center;margin:8px 0}
+.rp-controls input[type=range]{flex:1 1 200px;min-width:0;accent-color:var(--accent)}
+.rp-out{display:block;font-size:14px;padding:6px 10px;border:1px solid var(--edge);border-radius:8px;background:var(--bubble);overflow-wrap:anywhere}
+.rp-body h3{font-size:14px;color:var(--accent);margin:14px 0 6px}
+.rp-sum{margin:8px 0}
+.rp-lanes{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:8px}
+.rp-lane{background:var(--panel);border:1px solid var(--edge);border-top:3px solid var(--lc,var(--edge));border-radius:10px;padding:6px 8px;min-width:0}
+.rp-lane[data-lane=todo]{--lc:var(--todo)}.rp-lane[data-lane=doing]{--lc:var(--doing)}.rp-lane[data-lane=review]{--lc:var(--review)}.rp-lane[data-lane=blocked]{--lc:var(--blocked)}.rp-lane[data-lane=done]{--lc:var(--done)}
+.rp-lane h3{margin:0 0 6px;font-size:14px;display:flex;justify-content:space-between;gap:6px;color:var(--ink)}
+.rp-chips{display:flex;flex-wrap:wrap;gap:4px}
+.rp-chip{font-size:12px;border:1px solid var(--edge);border-left:4px solid var(--agc,var(--edge));border-radius:6px;padding:1px 6px;overflow-wrap:anywhere;max-width:100%}
+.rp-chip small{color:var(--muted)}
+.rp-recent{margin:0;padding-left:0;list-style:none;font-size:14px;display:flex;flex-direction:column;gap:3px;overflow-wrap:anywhere}

raidlock/web/replay/view.js

@@ -0,0 +1,127 @@
+"use strict";
+(function () {
+  const views = window.RaidlockViews = window.RaidlockViews || [];
+  const LANES = [["todo", "To do"], ["doing", "In progress"], ["review", "Review"], ["blocked", "Blocked"], ["done", "Done"]];
+  const STEP_MS = 700;
+  let st = null;
+  let inFlight = false;
+
+  function stop() {
+    if (st && st.timer) { clearInterval(st.timer); st.timer = 0; }
+    if (st && st.play) { st.play.setAttribute("aria-pressed", "false"); st.play.textContent = "Play"; }
+  }
+  function markText(m) {
+    if (!m) return "No records yet. The timeline fills as agents claim, note and move cards.";
+    return `#${m.seq} · ${st.c.localTime(m.ts)} · ${m.agent || "?"}: ${m.text || m.kind}`;
+  }
+  function label() {
+    const m = st.marks[st.idx];
+    st.c.setKids(st.out, [markText(m)]);
+    st.out.title = m ? m.ts : "";
+    st.range.setAttribute("aria-valuetext", m ? `record ${m.seq}, ${st.c.localTime(m.ts)}` : "empty");
+    st.play.disabled = !st.marks.length;
+    st.range.disabled = !st.marks.length;
+    st.prev.disabled = st.idx <= 0;
+    st.next.disabled = st.idx >= st.marks.length - 1;
+  }
+  function lanes(c, d) {
+    return c.h("div", {class: "rp-lanes"}, LANES.map(([id, name]) => {
+      const cards = (d.cards || []).filter(x => x.lane === id);
+      return c.h("section", {class: "rp-lane", "data-lane": id, "aria-label": name},
+        c.h("h3", null, name, c.h("span", {class: "count", text: String((d.counts || {})[id] || 0)})),
+        c.h("div", {class: "rp-chips"}, cards.length ? cards.map(x => c.h("span", {class: "rp-chip" + (x.owner ? " " + c.agentClass(x.owner) : ""), "data-id": x.id, title: x.title},
+          x.id, x.owner ? c.h("small", {text: " " + x.owner}) : null)) : c.h("span", {class: "cls", text: "none"})));
+    }));
+  }
+  function show(c, d, map) {
+    st.cur = d;
+    const recent = (d.recent || []).map(m => c.h("li", {class: "k-" + m.kind}, c.h("b", {text: `#${m.seq} ${m.agent || "?"}`}), ` ${m.kind}${m.task ? " on " + m.task : ""}${m.source && m.source !== "board" ? " (" + m.source + ")" : ""}: `, m.text || ""));
+    const ev = d.events || {};
+    const notes = [];
+    if (d.untracked) notes.push(`${d.untracked} cards have no creation record in the transcript and appear once they are first mentioned.`);
+    if (d.truncated) notes.push(`Only the newest ${st.marks.length} records are on the slider; older slider entries are omitted.`);
+    if (d.incomplete_history) notes.push(`Incomplete history: reconstruction stops at ${d.at}; true latest sequence is ${d.last}.`);
+    if (d.non_core_records) notes.push("Non-core or unknown records were skipped.");
+    if (map && map.error) notes.push("Incomplete territory: " + map.error);
+    const mapDef = c.def("map");
+    c.setKids(st.body, [
+      c.h("p", {class: "cls rp-sum", text: `${d.total} records · lock denials ${ev.lock_denied || 0} · write violations ${ev.lock_violation || 0} so far`}),
+      lanes(c, d),
+      c.h("h3", {text: "Locks at this point"}),
+      map && mapDef ? mapDef.legend(c, map) : null,
+      map && mapDef ? c.h("div", {class: "zones"}, mapDef.tiles(c, map)) : null,
+      c.h("h3", {text: "Records up to this point"}),
+      recent.length ? c.h("ul", {class: "rp-recent"}, recent) : c.h("p", {class: "cls", text: "Nothing yet."}),
+      notes.length ? c.h("p", {class: "note-sm", text: notes.join(" ")}) : null]);
+  }
+  async function load(c) {
+    const m = st.marks[st.idx];
+    if (!m || inFlight) return;
+    inFlight = true;
+    const owner = st;
+    const token = ++st.token;
+    try {
+      const d = await c.api("replay", `?at=${m.seq}&marks=0`);
+      const map = d && d.territory;
+      if (st === owner && token === st.token && d) show(c, d, map);
+    } catch (_) {} finally {
+      inFlight = false;
+      if (st === owner && st.marks[st.idx] !== m) load(c);
+    }
+  }
+  function scrub(c, i, now) {
+    st.idx = Math.max(0, Math.min(st.marks.length - 1, i));
+    st.range.value = String(st.idx);
+    label();
+    clearTimeout(st.debounce);
+    if (now) load(c); else st.debounce = setTimeout(() => load(c), 120);
+  }
+  function build(c, d, pane) {
+    stop();
+    st = {ws: c.ws, marks: d.marks || [], idx: Math.max(0, (d.marks || []).length - 1), timer: 0, token: 0, debounce: 0};
+    const max = Math.max(0, st.marks.length - 1);
+    st.range = c.h("input", {type: "range", min: "0", max: String(max), step: "1", value: String(st.idx), id: "replayRange", "aria-label": "Position in the transcript"});
+    st.prev = c.h("button", {type: "button", class: "tog", text: "Previous", "aria-label": "Previous record"});
+    st.next = c.h("button", {type: "button", class: "tog", text: "Next", "aria-label": "Next record"});
+    st.play = c.h("button", {type: "button", class: "tog", "aria-pressed": "false", text: "Play"});
+    st.live = c.h("button", {type: "button", class: "tog", text: "Refresh"});
+    st.out = c.h("output", {class: "rp-out", for: "replayRange"});
+    st.body = c.h("div", {class: "rp-body"});
+    st.range.addEventListener("input", () => { stop(); scrub(st.c, +st.range.value, false); });
+    st.prev.addEventListener("click", () => { stop(); scrub(st.c, st.idx - 1, true); });
+    st.next.addEventListener("click", () => { stop(); scrub(st.c, st.idx + 1, true); });
+    st.live.addEventListener("click", () => { stop(); st.ws = null; st.c.reload(); });
+    st.play.addEventListener("click", () => {
+      if (st.timer) { stop(); return; }
+      if (st.idx >= st.marks.length - 1) scrub(st.c, 0, true);
+      st.play.setAttribute("aria-pressed", "true");
+      st.play.textContent = "Pause";
+      st.timer = setInterval(() => {
+        if (inFlight) return;
+        if (!st || st.idx >= st.marks.length - 1) { stop(); return; }
+        scrub(st.c, st.idx + 1, true);
+      }, STEP_MS);
+    });
+    pane.replaceChildren(
+      c.h("div", {class: "view-head"}, c.h("h2", null, c.raid ? "Chronicle" : "Timeline", c.raid && c.raidSub ? c.raidSub("Timeline") : null),
+        c.h("p", {class: "cls", text: "The board rebuilt from the transcript at any point. Transcript records are not signed, so treat this as unverified history; lock paths use today's repo layout."})),
+      c.h("div", {class: "rp-controls"}, st.prev, st.range, st.next, st.play, st.live),
+      st.out, st.body);
+    st.c = c;
+    label();
+    show(c, d, d.territory);
+    if (st.marks.length) load(c);
+  }
+  views.push({
+    id: "replay",
+    endpoint: "replay",
+    label: {raid: "Chronicle", plain: "Timeline"},
+    poll: false,
+    leave() { stop(); },
+    render(c, d, pane) {
+      if (c.fresh || !st || st.ws !== c.ws || !pane.contains(st.range)) { build(c, d, pane); return; }
+      st.c = c;
+      if (st.cur) load(c);
+    }
+  });
+})();