skilldrop-cli 1.5.0 → 1.7.0

package/packs/event-planner/skills/run-of-show/examples/product-launch.svg

@@ -0,0 +1,58 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1280 316" width="1280" height="316" font-family="Helvetica, Arial, sans-serif">
+<rect width="1280" height="316" fill="#ffffff"/>
+<text x="20" y="28" font-size="16" font-weight="bold">Run of show</text>
+<line x1="150.0" y1="60" x2="150.0" y2="252" stroke="#cfd8dc"/>
+<text x="150.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">08:00</text>
+<line x1="205.0" y1="60" x2="205.0" y2="252" stroke="#eceff1"/>
+<line x1="260.0" y1="60" x2="260.0" y2="252" stroke="#cfd8dc"/>
+<text x="260.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">09:00</text>
+<line x1="315.0" y1="60" x2="315.0" y2="252" stroke="#eceff1"/>
+<line x1="370.0" y1="60" x2="370.0" y2="252" stroke="#cfd8dc"/>
+<text x="370.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">10:00</text>
+<line x1="425.0" y1="60" x2="425.0" y2="252" stroke="#eceff1"/>
+<line x1="480.0" y1="60" x2="480.0" y2="252" stroke="#cfd8dc"/>
+<text x="480.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">11:00</text>
+<line x1="535.0" y1="60" x2="535.0" y2="252" stroke="#eceff1"/>
+<line x1="590.0" y1="60" x2="590.0" y2="252" stroke="#cfd8dc"/>
+<text x="590.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">12:00</text>
+<line x1="645.0" y1="60" x2="645.0" y2="252" stroke="#eceff1"/>
+<line x1="700.0" y1="60" x2="700.0" y2="252" stroke="#cfd8dc"/>
+<text x="700.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">13:00</text>
+<line x1="755.0" y1="60" x2="755.0" y2="252" stroke="#eceff1"/>
+<line x1="810.0" y1="60" x2="810.0" y2="252" stroke="#cfd8dc"/>
+<text x="810.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">14:00</text>
+<line x1="865.0" y1="60" x2="865.0" y2="252" stroke="#eceff1"/>
+<line x1="920.0" y1="60" x2="920.0" y2="252" stroke="#cfd8dc"/>
+<text x="920.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">15:00</text>
+<line x1="975.0" y1="60" x2="975.0" y2="252" stroke="#eceff1"/>
+<line x1="1030.0" y1="60" x2="1030.0" y2="252" stroke="#cfd8dc"/>
+<text x="1030.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">16:00</text>
+<line x1="1085.0" y1="60" x2="1085.0" y2="252" stroke="#eceff1"/>
+<line x1="1140.0" y1="60" x2="1140.0" y2="252" stroke="#cfd8dc"/>
+<text x="1140.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">17:00</text>
+<line x1="1195.0" y1="60" x2="1195.0" y2="252" stroke="#eceff1"/>
+<line x1="1250.0" y1="60" x2="1250.0" y2="252" stroke="#cfd8dc"/>
+<text x="1250.0" y="57" font-size="10" text-anchor="middle" fill="#607d8b">18:00</text>
+<text x="20" y="96" font-size="12" fill="#263238">Auditorium</text><line x1="150" y1="124" x2="1250.0" y2="124" stroke="#b0bec5"/>
+<rect x="150.0" y="62" width="1100.0" height="60" fill="#f1f8e9" opacity="0.6"/>
+<rect x="205.0" y="68" width="55.0" height="48" fill="#fff8e1" stroke="#ffb300" stroke-dasharray="3,2"/>
+<rect x="260.0" y="66" width="82.5" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="264.0" y="84" font-size="10" fill="#0d47a1">Launch keyno…</text><text x="264.0" y="98" font-size="9" fill="#546e7a">09:00–09:45</text>
+<rect x="379.2" y="66" width="110.0" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="383.2" y="84" font-size="10" fill="#0d47a1">Customer panel</text><text x="383.2" y="98" font-size="9" fill="#546e7a">10:05–11:05</text>
+<rect x="535.0" y="66" width="110.0" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="539.0" y="84" font-size="10" fill="#0d47a1">Lunch</text><text x="539.0" y="98" font-size="9" fill="#546e7a">11:30–12:30</text>
+<rect x="1085.0" y="66" width="55.0" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="1089.0" y="84" font-size="10" fill="#0d47a1">Closing…</text><text x="1089.0" y="98" font-size="9" fill="#546e7a">16:30–17:00</text>
+<text x="20" y="160" font-size="12" fill="#263238">Demo lab</text><line x1="150" y1="188" x2="1250.0" y2="188" stroke="#b0bec5"/>
+<rect x="260.0" y="126" width="880.0" height="60" fill="#f1f8e9" opacity="0.6"/>
+<rect x="351.7" y="130" width="82.5" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="355.7" y="148" font-size="10" fill="#0d47a1">Live demo: s…</text><text x="355.7" y="162" font-size="9" fill="#546e7a">09:50–10:35</text>
+<rect x="700.0" y="130" width="275.0" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="704.0" y="148" font-size="10" fill="#0d47a1">Hands-on lab</text><text x="704.0" y="162" font-size="9" fill="#546e7a">13:00–15:30</text>
+<text x="20" y="224" font-size="12" fill="#263238">Foyer</text><line x1="150" y1="252" x2="1250.0" y2="252" stroke="#b0bec5"/>
+<rect x="150.0" y="190" width="1100.0" height="60" fill="#f1f8e9" opacity="0.6"/>
+<rect x="205.0" y="194" width="55.0" height="52" rx="4" fill="#e3f2fd" stroke="#1565c0" stroke-width="1"/>
+<text x="209.0" y="212" font-size="10" fill="#0d47a1">Doors a…</text><text x="209.0" y="226" font-size="9" fill="#546e7a">08:30–09:00</text>
+<text x="20" y="282" font-size="12" fill="#2e7d32">PASS: no clashes</text><text x="20" y="298" font-size="10" fill="#666">Dashed amber: setup before an item · green band: room open</text>
+</svg>

package/packs/event-planner/skills/run-of-show/manifest.json

@@ -0,0 +1,44 @@
+{
+  "name": "run-of-show",
+  "version": "0.1.1",
+  "description": "Turn an event's agenda into a timed run of show — every session, speaker, changeover and break with its start, end, room and who's needed — and check it with a script for two things in one room at once, a speaker booked in two places, changeovers shorter than the turnaround and anything outside venue hours, drawn as a timeline per room. Use when an organiser asks for \"a run of show\", \"a running order\", \"the minute-by-minute for the day\", \"check the agenda for clashes\", or has sessions, speakers and rooms for a conference, launch, festival or wedding day.",
+  "entrypoint": "SKILL.md",
+  "deps": {
+    "npm": [],
+    "pip": []
+  },
+  "env": {
+    "required": [],
+    "optional": []
+  },
+  "related": [
+    "seating-plan"
+  ],
+  "handoff": [
+    {
+      "to": "seating-plan",
+      "when": "the day includes a seated meal or dinner",
+      "purpose": "Seat the dinner guests so every together, apart and access request holds.",
+      "fallback": "If seating-plan is absent, list each table with its guests and check by hand that no table is over its count and every keep-apart pair is split."
+    }
+  ],
+  "tags": [
+    "events",
+    "run-of-show",
+    "agenda",
+    "schedule",
+    "conference",
+    "timeline",
+    "svg"
+  ],
+  "permissions": {
+    "network": [],
+    "commands": [],
+    "files": "named-paths",
+    "notes": "Reads the show.json it is given and writes the SVG to the path passed with --svg."
+  },
+  "model": {
+    "tier": "standard",
+    "rationale": "Ordering a day around rooms and people is bounded judgment; the script decides whether anything clashes."
+  }
+}

package/packs/event-planner/skills/run-of-show/scripts/show_check.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""Check an event's run of show for clashes and draw it as a timeline. Stdlib only.
+
+Reads a show.json: the rooms (opening hours, turnaround between items), the items (title,
+room, start, end or duration, the people needed, setup minutes needed in the room before it
+starts, changeover minutes needed after it), the travel minutes between rooms, and the
+published end of the day. It fails a show where
+  - an item ends before it starts
+  - two items overlap in one room
+  - the gap between two items in a room is shorter than the turnaround, the next item's
+    setup or the last item's changeover
+  - an item, with its setup, runs outside its room's opening hours
+  - a person is needed in two places at once, or has less than the travel time between
+    rooms
+and warns where
+  - a person works more than --max-hours without a break of --break minutes
+  - a room sits empty for more than --max-gap minutes between items
+  - the last item ends after the published end
+Then it prints the running order, and with --svg draws one lane per room with each item as
+a block at its times, failures in red.
+
+Times are 24-hour "HH:MM". Items on several days carry a "day" (any label, such as
+"2026-06-12" or "Day 2"); each day is checked on its own.
+
+Usage:
+  python3 show_check.py show.json [--svg timeline.svg] [--json]
+                        [--max-hours 3] [--break 15] [--max-gap 45]
+Exit codes: 0 no failures, 1 a failure, 2 bad input.
+"""
+import argparse
+import json
+import math
+import re
+import sys
+
+TIME = re.compile(r"^([01]?\d|2[0-4]):([0-5]\d)$")
+
+
+class BadInput(ValueError):
+    pass
+
+
+def minutes(v, what):
+    """'09:30' -> 570. Raises BadInput."""
+    m = TIME.match(str(v).strip()) if v is not None else None
+    if not m or (int(m.group(1)) == 24 and m.group(2) != "00"):
+        raise BadInput(f"{what} must be a 24-hour time like 09:30, got {v!r}")
+    return int(m.group(1)) * 60 + int(m.group(2))
+
+
+def hhmm(n):
+    return f"{int(n) // 60:02d}:{int(n) % 60:02d}"
+
+
+def _mins(v, what):
+    if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v) or v < 0:
+        raise BadInput(f"{what} must be a number of minutes, got {v!r}")
+    return float(v)
+
+
+def load(data):
+    if not isinstance(data, dict):
+        raise BadInput("the file must hold a JSON object")
+    default_turn = _mins(data.get("turnaround", 0), "turnaround")
+    rooms = {}
+    for i, r in enumerate(data.get("rooms") or []):
+        if not isinstance(r, dict) or not r.get("name"):
+            raise BadInput(f"room {i + 1} needs a name")
+        n = str(r["name"])
+        rooms[n] = {"name": n, "open": minutes(r["open"], f"room {n} open") if r.get("open") else None,
+                    "close": minutes(r["close"], f"room {n} close") if r.get("close") else None,
+                    "turnaround": _mins(r.get("turnaround", default_turn), f"room {n} turnaround")}
+    items = []
+    for i, it in enumerate(data.get("items") or []):
+        if not isinstance(it, dict) or not it.get("title"):
+            raise BadInput(f"item {i + 1} needs a title")
+        iid = str(it.get("id") or f"item {i + 1}")
+        room = str(it.get("room") or "")
+        if not room:
+            raise BadInput(f"{iid} ({it['title']}) needs a room")
+        if room not in rooms:
+            rooms[room] = {"name": room, "open": None, "close": None, "turnaround": default_turn}
+        start = minutes(it.get("start"), f"{iid} start")
+        if it.get("end") is not None:
+            end = minutes(it["end"], f"{iid} end")
+        elif it.get("duration") is not None:
+            end = start + _mins(it["duration"], f"{iid} duration")
+        else:
+            raise BadInput(f"{iid} ({it['title']}) needs an end or a duration")
+        people = it.get("people") or []
+        if isinstance(people, str):
+            people = [people]
+        items.append({"id": iid, "title": str(it["title"]), "room": room, "day": str(it.get("day") or ""),
+                      "start": start, "end": end, "people": [str(p) for p in people],
+                      "setup": _mins(it.get("setup", 0), f"{iid} setup"),
+                      "changeover": _mins(it.get("changeover", 0), f"{iid} changeover")})
+    if not items:
+        raise BadInput("no items")
+    travel = {}
+    for i, t in enumerate(data.get("travel") or []):
+        if not isinstance(t, dict) or not isinstance(t.get("between"), list) or len(t["between"]) != 2:
+            raise BadInput(f"travel {i + 1} must be {{\"between\": [room, room], \"minutes\": n}}")
+        a, b = (str(x) for x in t["between"])
+        travel[frozenset((a, b))] = _mins(t.get("minutes"), f"travel {i + 1} minutes")
+    end = minutes(data["published_end"], "published_end") if data.get("published_end") else None
+    return {"rooms": rooms, "items": items, "travel": travel, "published_end": end}
+
+
+def check(show, max_hours=3.0, brk=15.0, max_gap=45.0):
+    fails, warns, bad = [], [], set()
+    items = show["items"]
+    label = lambda it: f"{it['title']} ({hhmm(it['start'])}{', ' + it['day'] if it['day'] else ''})"
+    for it in items:
+        if it["end"] <= it["start"]:
+            fails.append(f"{label(it)} ends at {hhmm(it['end'])}, not after it starts")
+            bad.add(it["id"])
+    ok = [it for it in items if it["end"] > it["start"]]
+    groups = {}
+    for it in ok:
+        groups.setdefault((it["day"], it["room"]), []).append(it)
+    for (day, room), lane in groups.items():
+        r = show["rooms"][room]
+        lane.sort(key=lambda it: it["start"])
+        for it in lane:
+            if r["open"] is not None and it["start"] - it["setup"] < r["open"]:
+                need = f" with {it['setup']:.0f} min setup" if it["setup"] else ""
+                fails.append(f"{label(it)} starts{need} before {room} opens at {hhmm(r['open'])}")
+                bad.add(it["id"])
+            if r["close"] is not None and it["end"] > r["close"]:
+                fails.append(f"{label(it)} ends at {hhmm(it['end'])}, after {room} closes at {hhmm(r['close'])}")
+                bad.add(it["id"])
+        for a, b in zip(lane, lane[1:]):
+            gap = b["start"] - a["end"]
+            if gap < 0:
+                fails.append(f"{label(a)} and {label(b)} overlap in {room} by {-gap:.0f} min")
+                bad.update((a["id"], b["id"]))
+                continue
+            need = max(r["turnaround"], b["setup"], a["changeover"])
+            if gap < need:
+                why = ("the room's turnaround" if need == r["turnaround"] else
+                       f"{b['title']}'s setup" if need == b["setup"] else f"{a['title']}'s changeover")
+                fails.append(f"{room}: {gap:.0f} min between {label(a)} and {label(b)}, "
+                             f"{need:.0f} min needed for {why}")
+                bad.update((a["id"], b["id"]))
+            elif gap > max_gap:
+                warns.append(f"{room} is empty for {gap:.0f} min between {a['title']} and {b['title']}")
+    people = {}
+    for it in ok:
+        for p in it["people"]:
+            people.setdefault((it["day"], p), []).append(it)
+    for (day, p), mine in people.items():
+        mine.sort(key=lambda it: it["start"])
+        for a, b in zip(mine, mine[1:]):
+            gap = b["start"] - a["end"]
+            if gap < 0:
+                fails.append(f"{p} is needed at {label(a)} in {a['room']} and {label(b)} in {b['room']} at once")
+                bad.update((a["id"], b["id"]))
+            elif a["room"] != b["room"]:
+                t = show["travel"].get(frozenset((a["room"], b["room"])))
+                if t is not None and gap < t:
+                    fails.append(f"{p} has {gap:.0f} min to get from {a['room']} to {b['room']} "
+                                 f"between {a['title']} and {b['title']}; the walk takes {t:.0f}")
+                    bad.update((a["id"], b["id"]))
+        run_start, last_end = None, None
+        for it in mine:
+            if last_end is None or it["start"] - last_end >= brk:
+                run_start = it["start"]
+            last_end = max(last_end or it["end"], it["end"])
+            if last_end - run_start > max_hours * 60:
+                warns.append(f"{p} works from {hhmm(run_start)} to {hhmm(last_end)}"
+                             f"{' on ' + day if day else ''} without a {brk:.0f}-minute break")
+                run_start = math.inf  # one warning per stretch
+        # an inf run_start makes the difference negative until the next break resets it
+    if show["published_end"] is not None:
+        for day in sorted({it["day"] for it in ok}):
+            last = max((it for it in ok if it["day"] == day), key=lambda it: it["end"])
+            if last["end"] > show["published_end"]:
+                warns.append(f"{last['title']} ends at {hhmm(last['end'])}{', ' + day if day else ''}, "
+                             f"{last['end'] - show['published_end']:.0f} min after the published end "
+                             f"of {hhmm(show['published_end'])}")
+    return {"fails": fails, "warns": warns, "bad": sorted(bad)}
+
+
+def order(show):
+    return sorted(show["items"], key=lambda it: (it["day"], it["start"], it["room"]))
+
+
+def report(show, r):
+    out, day = [], None
+    for it in order(show):
+        if it["day"] != day and it["day"]:
+            out.append(it["day"])
+        day = it["day"]
+        who = f" — {', '.join(it['people'])}" if it["people"] else ""
+        out.append(f"  {hhmm(it['start'])}–{hhmm(it['end'])}  {it['room']}: {it['title']}{who}")
+    out += [f"FAIL {f}" for f in r["fails"]] + [f"WARN {w}" for w in r["warns"]]
+    out.append("PASS" if not r["fails"] else f"{len(r['fails'])} failure(s)")
+    return "\n".join(out) + "\n"
+
+
+def esc(t):
+    return str(t).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
+
+
+def svg(show, r, px=3.0, lane=64):
+    """One panel per day: a lane per room, a block per item, a tick every 30 minutes."""
+    days = sorted({it["day"] for it in show["items"]})
+    rooms = list(show["rooms"])
+    out_body, y = [], 50
+    width = 0
+    for day in days:
+        its = [it for it in show["items"] if it["day"] == day]
+        t0 = min(min(it["start"] for it in its), *(show["rooms"][it["room"]]["open"] or it["start"] for it in its))
+        t1 = max(max(it["end"] for it in its), *(show["rooms"][it["room"]]["close"] or it["end"] for it in its))
+        t0, t1 = 30 * math.floor(t0 / 30), 30 * math.ceil(t1 / 30)
+        scale = min(px, 1100.0 / max(t1 - t0, 30))  # a long day still fits a page
+        X = lambda t, t0=t0, scale=scale: 150 + (t - t0) * scale
+        width = max(width, X(t1) + 30)
+        if day:
+            out_body.append(f'<text x="20" y="{y:.0f}" font-size="14" font-weight="bold">{esc(day)}</text>')
+            y += 14
+        top = y + 10
+        for t in range(int(t0), int(t1) + 1, 30):
+            major = t % 60 == 0
+            out_body.append(f'<line x1="{X(t):.1f}" y1="{top:.0f}" x2="{X(t):.1f}" y2="{top + lane * len(rooms):.0f}" '
+                            f'stroke="{"#cfd8dc" if major else "#eceff1"}"/>')
+            if major:
+                out_body.append(f'<text x="{X(t):.1f}" y="{top - 3:.0f}" font-size="10" text-anchor="middle" fill="#607d8b">{hhmm(t)}</text>')
+        for k, room in enumerate(rooms):
+            ly = top + k * lane
+            rm = show["rooms"][room]
+            out_body.append(f'<text x="20" y="{ly + lane / 2 + 4:.0f}" font-size="12" fill="#263238">{esc(room)}</text>'
+                            f'<line x1="150" y1="{ly + lane:.0f}" x2="{X(t1):.1f}" y2="{ly + lane:.0f}" stroke="#b0bec5"/>')
+            if rm["open"] is not None and rm["close"] is not None:
+                out_body.append(f'<rect x="{X(rm["open"]):.1f}" y="{ly + 2:.0f}" width="{(rm["close"] - rm["open"]) * scale:.1f}" '
+                                f'height="{lane - 4}" fill="#f1f8e9" opacity="0.6"/>')
+            for it in its:
+                if it["room"] != room:
+                    continue
+                bad = it["id"] in r["bad"]
+                x0, w = X(it["start"]), max((it["end"] - it["start"]) * scale, 2)
+                if it["setup"]:
+                    out_body.append(f'<rect x="{x0 - it["setup"] * scale:.1f}" y="{ly + 8:.0f}" width="{it["setup"] * scale:.1f}" '
+                                    f'height="{lane - 16}" fill="#fff8e1" stroke="#ffb300" stroke-dasharray="3,2"/>')
+                out_body.append(f'<rect x="{x0:.1f}" y="{ly + 6:.0f}" width="{w:.1f}" height="{lane - 12}" rx="4" '
+                                f'fill="{"#ffebee" if bad else "#e3f2fd"}" stroke="{"#c62828" if bad else "#1565c0"}" '
+                                f'stroke-width="{2.5 if bad else 1}"/>')
+                title = it["title"] if len(it["title"]) * 6 < w - 6 else it["title"][: max(int((w - 10) / 6), 1)] + "…"
+                out_body.append(f'<text x="{x0 + 4:.1f}" y="{ly + 24:.0f}" font-size="10" fill="#0d47a1">{esc(title)}</text>'
+                                f'<text x="{x0 + 4:.1f}" y="{ly + 38:.0f}" font-size="9" fill="#546e7a">'
+                                f'{hhmm(it["start"])}–{hhmm(it["end"])}{" ✗" if bad else ""}</text>')
+        y = top + lane * len(rooms) + 30
+    status = "PASS: no clashes" if not r["fails"] else f"{len(r['fails'])} clash(es): items marked ✗ in red"
+    out_body.append(f'<text x="20" y="{y:.0f}" font-size="12" fill="{"#2e7d32" if not r["fails"] else "#c62828"}">{esc(status)}</text>'
+                    f'<text x="20" y="{y + 16:.0f}" font-size="10" fill="#666">Dashed amber: setup before an item · '
+                    f'green band: room open</text>')
+    H, W = y + 34, max(width, 520)
+    head = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {W:.0f} {H:.0f}" width="{W:.0f}" height="{H:.0f}" '
+            'font-family="Helvetica, Arial, sans-serif">', f'<rect width="{W:.0f}" height="{H:.0f}" fill="#ffffff"/>',
+            '<text x="20" y="28" font-size="16" font-weight="bold">Run of show</text>']
+    return "\n".join(head + out_body + ["</svg>"]) + "\n"
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Check a run of show for clashes and draw it as a timeline.")
+    ap.add_argument("show")
+    ap.add_argument("--svg", help="write the timeline here")
+    ap.add_argument("--json", action="store_true", help="print the result as JSON")
+    ap.add_argument("--max-hours", type=float, default=3.0, help="hours a person may work without a break (default 3)")
+    ap.add_argument("--break", dest="brk", type=float, default=15.0, help="minutes that count as a break (default 15)")
+    ap.add_argument("--max-gap", type=float, default=45.0, help="minutes a room may sit empty between items (default 45)")
+    args = ap.parse_args(argv)
+    try:
+        with open(args.show, encoding="utf-8") as fh:
+            show = load(json.load(fh))
+    except (OSError, ValueError) as e:
+        print(f"FAIL cannot read {args.show}: {e}")
+        return 2
+    r = check(show, args.max_hours, args.brk, args.max_gap)
+    if args.json:
+        print(json.dumps({"pass": not r["fails"], "fails": r["fails"], "warns": r["warns"],
+                          "items": [dict(it, start=hhmm(it["start"]), end=hhmm(it["end"])) for it in order(show)]},
+                         indent=1))
+    else:
+        print(report(show, r), end="")
+    if args.svg:
+        with open(args.svg, "w", encoding="utf-8") as fh:
+            fh.write(svg(show, r))
+        if not args.json:
+            print(f"\nWrote {args.svg}")
+    return 1 if r["fails"] else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/packs/event-planner/skills/run-of-show/templates/show.json

@@ -0,0 +1,15 @@
+{
+  "published_end": "17:30",
+  "turnaround": 10,
+  "rooms": [
+    {"name": "Main hall", "open": "08:00", "close": "18:00", "turnaround": 15},
+    {"name": "Studio B", "open": "09:00", "close": "17:30"}
+  ],
+  "travel": [{"between": ["Main hall", "Studio B"], "minutes": 5}],
+  "items": [
+    {"id": "doors", "title": "Doors and registration", "room": "Main hall", "start": "08:30", "end": "09:00", "people": ["Front of house"]},
+    {"id": "key", "title": "Opening keynote", "room": "Main hall", "start": "09:15", "duration": 45, "people": ["Ana Ruiz", "AV crew"], "setup": 15},
+    {"id": "ws1", "title": "Workshop: pricing", "room": "Studio B", "start": "10:10", "end": "11:00", "people": ["Ana Ruiz"]},
+    {"id": "panel", "title": "Customer panel", "room": "Main hall", "start": "10:15", "end": "11:15", "people": ["Joe Park", "AV crew"], "changeover": 20}
+  ]
+}

package/packs/event-planner/skills/seating-plan/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: seating-plan
+description: Seat guests at tables for a wedding, gala, conference dinner or awards night, and check the chart with a script — every guest seated once, no table over capacity, people who must sit together together, people who must be kept apart apart, wheelchair users at accessible places — drawn as a room plan with names at each table. Use when an organiser asks to "make the seating plan", "who sits where", "seat these 120 guests", "check my table plan", or has a guest list with groups and keep-apart requests.
+---
+
+# seating-plan
+
+A table plan for a seated event, where every rule the organiser gave holds at once: each guest
+has exactly one seat, no table is over its count, households and groups sit together, the
+people who must be kept apart are, and wheelchair users are at tables with step-free access.
+With 120 guests and a dozen requests, a plan that looks right usually breaks one of them. The
+agent decides who sits where and why; a script checks every rule on every table and draws the
+room, so a broken request is found before the organiser prints place cards.
+
+## How to respond
+
+**These rules come before the steps and outrank them:**
+
+- **Their file comes back in exactly its own shape.** Fixing their plan, return their file
+  with the same columns, column order, headers and row order, and only the cells a rule
+  forces changed, ready for the venue to print from. Building from a guest list, hand back
+  their columns plus only the table (and seat) columns the plan needs. Every change goes in
+  the reply, not the file: the guest, what moved and why. Add a change column, or any other
+  column, only when they ask for one. Given a pasted list, reply with a table. Write every
+  deliverable the request names, such as place-card order or the caterer's list.
+- **Working files stay out of sight.** The checker's input and any intermediate file go in a
+  temporary folder outside the working directory, or are deleted before you reply. Draw the
+  room only when a drawing is asked for or the venue needs a floor plan, and then once. Never
+  leave anything running in the background.
+- **Carry every field through, without reshaping their file.** Every detail the person gave
+  per guest (meal choice, dietary need, party, notes) reaches the reply or the deliverable it
+  belongs in, such as the caterer's list, and each conflict between them is flagged: a vegan
+  guest who chose the beef, a child in a seat marked for a speaker.
+- **Soft notes are rules.** "Keep the grandparents near the door", "not by the speakers":
+  build them in, and say which you couldn't meet.
+- **Fixing their plan means minimal changes.** Move only the guests a rule forces, list each
+  move with the rule, and keep every other seat as they placed it.
+- **A passing check is the floor, not the reply.** The reply is about their guests, in their
+  words: never file formats, tools or paths.
+
+1. **Collect the guest list and the rules.** Take them from the files the organiser names (a
+   guest list CSV or spreadsheet export, an RSVP export, a pasted list) or the message:
+   - **Guests:** name, household or party, and needs: wheelchair, near an exit, dietary
+     (dietary and meal choice are carried through to the deliverable, not seating rules)
+   - **Tables:** how many, seats each, round or long, which are step-free, and where they
+     stand, if a room layout exists
+   - **Requests:** who must sit together, who must be kept apart, fixed seats (the head table,
+     a sponsor's table)
+
+   Ask at most two questions, only about a rule that changes the plan. With no guests, emit
+   `BLOCKED: need the guest list`.
+
+2. **Write the plan file** in the shape of [`templates/seating.json`](templates/seating.json):
+   `tables` (id, capacity, shape, `at` in metres, `accessible`), `guests` (id, name, party,
+   needs, dietary), `together`, `apart`, `fixed`, and `assignments` as table → guest ids.
+   Seat in this order, because each step narrows the next:
+   1. fixed seats;
+   2. wheelchair users and anyone who must be near an exit, at the tables that allow it;
+   3. together groups and households, whole;
+   4. the apart pairs, kept on different tables;
+   5. everyone else, filling tables evenly rather than leaving one half empty.
+
+3. **Run the checker and fix every FAIL before showing anything.** Keep `seating.json` in a
+   temporary folder; a drawing, when wanted, goes in the working directory as
+   `seating-plan.svg`, never inside this folder.
+
+   ```bash
+   # Claude Code
+   python3 "${CLAUDE_SKILL_DIR}/scripts/seating_check.py" "$TMPDIR/seating.json"
+   # Other IDEs (from the skill folder); add --svg only when a drawing is wanted
+   python3 scripts/seating_check.py /tmp/seating/seating.json --svg seating-plan.svg
+   ```
+
+   Exit 0 means every rule holds; 1 means one is broken; 2 means the file is malformed. Move
+   guests and rerun until it exits 0. A WARN (a household split because it is bigger than a
+   table, a half-empty table, someone who came alone at a table of one family) stands only
+   with a sentence saying why.
+
+4. **When the rules can't all hold, say which and stop guessing.** Name the conflict and the
+   smallest change that resolves it: ✅ *"The Moss and Park families (14 people) must sit
+   together, and Ed and Bo must be kept apart, but Ed is in the Park group and Bo in the Moss:
+   with 10-seat tables they can't share one, so one family splits. Splitting the Parks 6 + 4
+   keeps every other request."* Never break a request quietly to make the plan pass.
+
+5. **Reply for the organiser, in this order:**
+   1. **The plan:** in their file's format when they gave one, otherwise a table of each
+      table and who sits there, step-free tables marked.
+   2. **What couldn't be met,** with the reason and the choice it needs from them.
+   3. **The assumptions,** each tagged `[assumption]`: a seat count or a layout they didn't give.
+   4. **The caterer's list:** meal choice and dietary need per guest and per table, with each
+      conflict flagged.
+   5. **The files:** their plan in their format, and the drawing if one was made.
+
+   Write for someone planning an event: no file formats, no tool or script names, no paths
+   inside this folder. Say *"every request is met"*, not what checked it.
+
+**Checking a plan the organiser already made:** run the same checker on their plan, report
+each problem with the fix that disturbs the fewest guests, and hand back their file with
+those fixes made and noted. Don't reseat the room unless they ask.
+
+**Non-interactive runs** (subagent, CI, headless): with no table size, use 10-seat rounds; with
+no layout, draw tables in a grid; with no accessible tables named, mark the ones nearest an
+exit, each tagged `[assumption]` at the top of the reply. With no guest list, emit
+`BLOCKED: need the guest list`.
+
+## Useful references in this skill
+
+- [`templates/seating.json`](templates/seating.json) — the file shape: tables, guests, requests and assignments
+- [`scripts/seating_check.py`](scripts/seating_check.py) — checks every guest seated once, capacity, together, apart, access and fixed seats; draws the room
+- [`examples/wedding-dinner.md`](examples/wedding-dinner.md) — worked example: a 24-guest wedding where the brief itself conflicts, and the reply names it
+
+The order-of-the-day timings, the speeches and the changeovers belong to `run-of-show`.
+
+## Quality bar
+
+- **Every guest has exactly one seat, and no table is over its count.** The checker exits 0 before the plan is shown.
+- **Every together group and every apart pair holds,** or the reply names the one that can't and why.
+- **Every wheelchair user is at a step-free table,** and every fixed seat is where it was fixed.
+- **Tables fill evenly:** no half-empty table without a reason.
+- **The reply leads with who sits where,** in a table the organiser could print.
+- **Nothing is invented:** no guest, request or table that wasn't given.
+- **Their file comes back in its exact columns and row order,** with every change listed in the reply, not in the file.
+- **Every detail they gave per guest reaches the reply or the deliverable it belongs in,** and each conflict is flagged.
+- **Their notes are honoured,** and their own plan changes only where a rule forces it.
+- **No working file is left in their folder.**
+
+## When to use this skill
+
+- ✅ A seating chart for a wedding, gala, awards dinner or conference dinner
+- ✅ Checking an existing table plan before the place cards are printed
+- ✅ Reseating after late RSVPs or a new keep-apart request
+- ✅ A plan for 20 guests or 400
+
+## When NOT to use this skill
+
+- ❌ The order of the day, speeches and changeovers: that's `run-of-show`
+- ❌ Theatre or classroom seating with numbered rows and no groups: it's a seat count, not a plan
+- ❌ Furniture placement and clearances in a room: that's a layout drawing
+- ❌ Choosing the venue or the menu
+
+## Anti-patterns to avoid
+
+- ❌ **Showing a plan before every rule is checked.** A keep-apart pair at table 7 is the one guests notice.
+- ❌ **Breaking a request quietly to make the numbers fit.** Name the conflict and let the organiser choose.
+- ❌ **Seating in guest-list order.** Fixed seats, access needs and groups go first, or they end up split.
+- ❌ **One half-empty table at the back** while others are full. Spread the space.
+- ❌ **Mentioning files, formats or tools in the reply.** The organiser wants names at tables.
+- ❌ **An extra "change" or "dietary" column in the venue's file.** They print from its exact columns; the changes and the meals go in the reply or the caterer's list.
+- ❌ **Treating dietary needs as a seating rule.** They go to the caterer, per guest and table.
+- ❌ **Dropping a column the person gave.** The meal choices are what the venue needs next.
+- ❌ **A JSON file and a drawing nobody asked for** left beside their guest list.
+- ❌ **Telling them the fixes instead of making them.** Hand back the corrected file.

package/packs/event-planner/skills/seating-plan/evals/eval_queries.json

@@ -0,0 +1,30 @@
+[
+ {
+  "query": "make the seating plan for our wedding, 120 guests, here's the list",
+  "should_trigger": true
+ },
+ {
+  "query": "who sits where at the gala? keep the board apart from the press",
+  "should_trigger": true
+ },
+ {
+  "query": "check my table plan before I print the place cards",
+  "should_trigger": true
+ },
+ {
+  "query": "seat these conference dinner guests by company, tables of 10",
+  "should_trigger": true
+ },
+ {
+  "query": "write the minute-by-minute for the wedding day",
+  "should_trigger": false
+ },
+ {
+  "query": "draw a floor plan for the venue's new function room, 12 x 18 m",
+  "should_trigger": false
+ },
+ {
+  "query": "map the guest's journey from booking a ticket to arriving at the gala",
+  "should_trigger": false
+ }
+]