skilldrop-cli 1.6.0 → 1.7.0

package/packs/event-planner/skills/seating-plan/scripts/seating_check.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""Check a table seating plan against its rules and draw the room. Stdlib only.
+
+Reads a seating.json: the tables (capacity, shape, position in metres, accessible or not),
+the guests (name, party or household, needs), the rules (groups that sit together, pairs
+kept apart, fixed seats) and the assignments (table -> guests). It fails a plan where
+  - a guest is unseated, or seated twice
+  - a table holds more guests than its capacity
+  - a together group is split across tables
+  - an apart pair shares a table
+  - a wheelchair user sits at a table not marked accessible
+  - a guest with a fixed seat is not at that table
+and warns where
+  - a household or party that would fit at one table is split
+  - a table is under half full, or empty
+  - a guest who came alone sits at a table where everyone else is one other party
+  - a guest who needs to be near an exit is further than --exit-distance from one (when
+    the room's exits are given)
+Then it lists every table with its guests and dietary needs, and with --svg draws the room:
+tables at their positions, labelled with their fill, names around each, failures in red.
+
+Usage:
+  python3 seating_check.py seating.json [--svg room.svg] [--json] [--exit-distance 8]
+Exit codes: 0 no failures, 1 a failure, 2 bad input.
+"""
+import argparse
+import json
+import math
+import sys
+
+
+class BadInput(ValueError):
+    pass
+
+
+def _num(v, what):
+    if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v):
+        raise BadInput(f"{what} must be a number, got {v!r}")
+    return float(v)
+
+
+def _point(v, what):
+    if not isinstance(v, (list, tuple)) or len(v) != 2:
+        raise BadInput(f"{what} must be [x, y] in metres")
+    return (_num(v[0], what + " x"), _num(v[1], what + " y"))
+
+
+def load(data):
+    """Validate the raw JSON and return a normalised plan. Raises BadInput."""
+    if not isinstance(data, dict):
+        raise BadInput("the file must hold a JSON object")
+    tables, guests = {}, {}
+    for i, t in enumerate(data.get("tables") or []):
+        if not isinstance(t, dict) or not t.get("id"):
+            raise BadInput(f"table {i + 1} needs an id")
+        tid = str(t["id"])
+        if tid in tables:
+            raise BadInput(f"two tables are called {tid!r}")
+        cap = _num(t.get("capacity", 10), f"table {tid} capacity")
+        if cap < 1 or cap != int(cap):
+            raise BadInput(f"table {tid} capacity must be a whole number of seats")
+        shape = str(t.get("shape", "round"))
+        if shape not in ("round", "rect"):
+            raise BadInput(f"table {tid} shape must be round or rect")
+        tables[tid] = {"id": tid, "capacity": int(cap), "shape": shape,
+                       "at": _point(t["at"], f"table {tid} position") if "at" in t else None,
+                       "accessible": bool(t.get("accessible", False)), "label": str(t.get("label", ""))}
+    if not tables:
+        raise BadInput("no tables")
+    for i, g in enumerate(data.get("guests") or []):
+        if not isinstance(g, dict) or not g.get("id"):
+            raise BadInput(f"guest {i + 1} needs an id")
+        gid = str(g["id"])
+        if gid in guests:
+            raise BadInput(f"two guests have the id {gid!r}")
+        needs = g.get("needs") or []
+        if isinstance(needs, str):
+            needs = [needs]
+        guests[gid] = {"id": gid, "name": str(g.get("name") or gid), "party": str(g.get("party") or ""),
+                       "needs": [str(n).lower() for n in needs], "dietary": str(g.get("dietary") or "")}
+    if not guests:
+        raise BadInput("no guests")
+
+    def known(gid, where):
+        if str(gid) not in guests:
+            raise BadInput(f"{where} names a guest {gid!r} who is not on the guest list")
+        return str(gid)
+
+    together = []
+    for i, grp in enumerate(data.get("together") or []):
+        if not isinstance(grp, list) or len(grp) < 2:
+            raise BadInput(f"together group {i + 1} must list two or more guests")
+        together.append([known(x, f"together group {i + 1}") for x in grp])
+    apart = []
+    for i, pair in enumerate(data.get("apart") or []):
+        if not isinstance(pair, list) or len(pair) != 2:
+            raise BadInput(f"apart pair {i + 1} must list exactly two guests")
+        apart.append([known(x, f"apart pair {i + 1}") for x in pair])
+    fixed = {}
+    if not isinstance(data.get("fixed") or {}, dict):
+        raise BadInput("fixed must map a guest id to a table id")
+    for gid, tid in (data.get("fixed") or {}).items():
+        if str(tid) not in tables:
+            raise BadInput(f"the fixed seat for {gid} names a table {tid!r} that does not exist")
+        fixed[known(gid, "fixed")] = str(tid)
+
+    raw = data.get("assignments") or {}
+    if not isinstance(raw, dict):
+        raise BadInput("assignments must map each table id to a list of guest ids")
+    seats = {tid: [] for tid in tables}
+    for tid, gl in raw.items():
+        if str(tid) not in tables:
+            raise BadInput(f"assignments name a table {tid!r} that does not exist")
+        if not isinstance(gl, list):
+            raise BadInput(f"assignments for table {tid} must be a list of guest ids")
+        seats[str(tid)] += [known(g, f"table {tid}") for g in gl]
+    exits = [_point(e, f"exit {i + 1}") for i, e in enumerate(data.get("exits") or [])]
+    room = data.get("room") or {}
+    if not isinstance(room, dict):
+        raise BadInput("room must be {\"width\": metres, \"depth\": metres}")
+    return {"tables": tables, "guests": guests, "together": together, "apart": apart, "fixed": fixed,
+            "seats": seats, "exits": exits,
+            "room": (_num(room["width"], "room width"), _num(room["depth"], "room depth"))
+            if room.get("width") and room.get("depth") else None}
+
+
+def check(plan, exit_distance=8.0):
+    tables, guests, seats = plan["tables"], plan["guests"], plan["seats"]
+    fails, warns, bad_tables = [], [], set()
+    where = {}
+    for tid, gl in seats.items():
+        for g in gl:
+            where.setdefault(g, []).append(tid)
+    name = lambda g: guests[g]["name"]
+    for g in guests:
+        at = where.get(g, [])
+        if not at:
+            fails.append(f"{name(g)} has no seat")
+        elif len(at) > 1:
+            fails.append(f"{name(g)} is seated more than once ({', '.join(at)})")
+            bad_tables.update(at)
+    table_of = {g: at[0] for g, at in where.items() if len(at) == 1}
+    for tid, gl in seats.items():
+        t = tables[tid]
+        if len(gl) > t["capacity"]:
+            fails.append(f"table {tid} has {len(gl)} guests for {t['capacity']} seats")
+            bad_tables.add(tid)
+    for grp in plan["together"]:
+        at = {table_of.get(g) for g in grp if g in table_of}
+        if len(at) > 1:
+            fails.append("must sit together but are split: " + ", ".join(f"{name(g)} ({table_of.get(g, 'unseated')})" for g in grp))
+            bad_tables.update(t for t in at if t)
+    for a, b in plan["apart"]:
+        if a in table_of and table_of.get(a) == table_of.get(b):
+            fails.append(f"{name(a)} and {name(b)} must be kept apart but both sit at table {table_of[a]}")
+            bad_tables.add(table_of[a])
+    for g, tid in table_of.items():
+        if "wheelchair" in guests[g]["needs"] and not tables[tid]["accessible"]:
+            fails.append(f"{name(g)} uses a wheelchair but table {tid} is not marked accessible")
+            bad_tables.add(tid)
+    for g, tid in plan["fixed"].items():
+        if table_of.get(g) != tid:
+            fails.append(f"{name(g)} has a fixed seat at table {tid} but sits at {table_of.get(g, 'no table')}")
+            bad_tables.add(tid)
+
+    biggest = max(t["capacity"] for t in tables.values())
+    parties = {}
+    for g, info in guests.items():
+        if info["party"]:
+            parties.setdefault(info["party"], []).append(g)
+    for party, members in sorted(parties.items()):
+        at = sorted({table_of[g] for g in members if g in table_of})
+        if len(at) > 1 and len(members) <= biggest:
+            warns.append(f"the {party} party ({len(members)}) is split across tables {', '.join(at)}")
+    for tid, gl in seats.items():
+        cap = tables[tid]["capacity"]
+        if not gl:
+            warns.append(f"table {tid} is empty")
+        elif len(gl) < cap / 2:
+            warns.append(f"table {tid} is under half full ({len(gl)} of {cap})")
+    in_group = {g for grp in plan["together"] for g in grp}
+    for g, tid in table_of.items():
+        p = guests[g]["party"]
+        alone = (not p or len(parties.get(p, [])) == 1) and g not in in_group
+        others = [o for o in seats[tid] if o != g]
+        other_parties = {guests[o]["party"] for o in others}
+        if alone and len(others) >= 2 and len(other_parties) == 1 and "" not in other_parties:
+            warns.append(f"{name(g)} came alone and is the only guest at table {tid} not in the {other_parties.pop()} party")
+    if plan["exits"]:
+        for g, tid in table_of.items():
+            t = tables[tid]
+            if "near exit" in guests[g]["needs"] and t["at"]:
+                d = min(math.dist(t["at"], e) for e in plan["exits"])
+                if d > exit_distance:
+                    warns.append(f"{name(g)} needs to be near an exit but table {tid} is {d:.1f} m from the nearest")
+    return {"fails": fails, "warns": warns, "bad_tables": sorted(bad_tables), "table_of": table_of,
+            "seated": len(table_of), "guests": len(guests),
+            "seats": sum(t["capacity"] for t in tables.values())}
+
+
+def table_rows(plan, r):
+    rows = []
+    for tid, t in plan["tables"].items():
+        gl = plan["seats"][tid]
+        diet = {}
+        for g in gl:
+            d = plan["guests"][g]["dietary"]
+            if d:
+                diet[d] = diet.get(d, 0) + 1
+        rows.append({"table": tid, "shape": t["shape"], "capacity": t["capacity"], "accessible": t["accessible"],
+                     "seated": len(gl), "guests": [plan["guests"][g]["name"] for g in gl], "dietary": diet,
+                     "ok": tid not in r["bad_tables"]})
+    return rows
+
+
+def report(plan, r):
+    out = [f"{r['seated']} of {r['guests']} guests seated, {len(plan['tables'])} tables, {r['seats']} seats."]
+    for row in table_rows(plan, r):
+        flags = ("accessible, " if row["accessible"] else "") + f"{row['seated']}/{row['capacity']}"
+        diet = ("; " + ", ".join(f"{n} {d}" for d, n in sorted(row["dietary"].items()))) if row["dietary"] else ""
+        out.append(f"  {row['table']} ({row['shape']}, {flags}{diet}): {', '.join(row['guests']) or '-'}")
+    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 layout(plan):
+    """Positions for every table: given ones, or a grid for tables without one."""
+    pos, n = {}, 0
+    for tid, t in plan["tables"].items():
+        if t["at"]:
+            pos[tid] = t["at"]
+    cols = max(1, math.ceil(math.sqrt(len(plan["tables"]))))
+    for tid, t in plan["tables"].items():
+        if tid not in pos:
+            pos[tid] = (2.5 + 4.0 * (n % cols), 2.5 + 4.0 * (n // cols))
+            n += 1
+    return pos
+
+
+def svg(plan, r, scale=40):
+    pos = layout(plan)
+    radius = lambda t: 0.45 + 0.09 * t["capacity"]  # metres, so a 10-seat round is about 1.35 m
+    xs = [p[0] for p in pos.values()] + [e[0] for e in plan["exits"]]
+    ys = [p[1] for p in pos.values()] + [e[1] for e in plan["exits"]]
+    w, d = plan["room"] or (max(xs) + 3, max(ys) + 3)
+    W, H = w * scale + 80, d * scale + 110
+    P = lambda x, y: (40 + x * scale, 60 + y * scale)
+    out = [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"/>',
+           f'<text x="40" y="30" font-size="16" font-weight="bold">Seating plan: {r["seated"]} of {r["guests"]} guests, '
+           f'{len(plan["tables"])} tables</text>',
+           f'<rect x="40" y="60" width="{w * scale:.0f}" height="{d * scale:.0f}" fill="#fafafa" stroke="#444" stroke-width="2"/>']
+    for i, e in enumerate(plan["exits"]):
+        x, y = P(*e)
+        out.append(f'<rect x="{x - 14:.0f}" y="{y - 6:.0f}" width="28" height="12" fill="#2e7d32"/>'
+                   f'<text x="{x:.0f}" y="{y + 22:.0f}" font-size="10" text-anchor="middle" fill="#2e7d32">EXIT</text>')
+    for tid, t in plan["tables"].items():
+        x, y = P(*pos[tid])
+        rad = radius(t) * scale
+        bad = tid in r["bad_tables"]
+        stroke, fill = ("#c62828", "#ffebee") if bad else ("#455a64", "#eceff1")
+        if t["shape"] == "round":
+            out.append(f'<circle cx="{x:.0f}" cy="{y:.0f}" r="{rad:.0f}" fill="{fill}" stroke="{stroke}" stroke-width="{3 if bad else 1.5}"/>')
+        else:
+            out.append(f'<rect x="{x - rad * 1.4:.0f}" y="{y - rad * 0.6:.0f}" width="{rad * 2.8:.0f}" height="{rad * 1.2:.0f}" '
+                       f'fill="{fill}" stroke="{stroke}" stroke-width="{3 if bad else 1.5}"/>')
+        gl = plan["seats"][tid]
+        mark = " ✗" if bad else ""
+        acc = " · accessible" if t["accessible"] else ""
+        out.append(f'<text x="{x:.0f}" y="{y - 2:.0f}" font-size="13" font-weight="bold" text-anchor="middle" '
+                   f'fill="{stroke}">{esc(tid)}{mark}</text>'
+                   f'<text x="{x:.0f}" y="{y + 13:.0f}" font-size="10" text-anchor="middle" fill="#555">{len(gl)}/{t["capacity"]}{acc}</text>')
+        rx, ry = (rad + 8, rad + 8) if t["shape"] == "round" else (rad * 1.4 + 10, rad * 0.6 + 10)
+        for k, g in enumerate(gl):
+            a = -math.pi / 2 + 2 * math.pi * k / max(len(gl), 1)
+            gx, gy = x + rx * math.cos(a), y + ry * math.sin(a)
+            anchor = "start" if math.cos(a) > 0.2 else ("end" if math.cos(a) < -0.2 else "middle")
+            out.append(f'<text x="{gx:.0f}" y="{gy + 3:.0f}" font-size="9" text-anchor="{anchor}" fill="#222">'
+                       f'{esc(plan["guests"][g]["name"])}</text>')
+    ly = 60 + d * scale + 28
+    status = "PASS: every rule met" if not r["fails"] else f"{len(r['fails'])} rule(s) broken: tables marked ✗ in red"
+    out.append(f'<text x="40" y="{ly:.0f}" font-size="12" fill="{"#2e7d32" if not r["fails"] else "#c62828"}">{esc(status)}</text>')
+    out.append(f'<text x="40" y="{ly + 18:.0f}" font-size="10" fill="#666">Positions in metres, '
+               f'1 m = {scale} px · names run clockwise from the top of each table</text>')
+    out.append("</svg>")
+    return "\n".join(out) + "\n"
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="Check a seating plan against its rules and draw the room.")
+    ap.add_argument("seating")
+    ap.add_argument("--svg", help="write the room plan here")
+    ap.add_argument("--json", action="store_true", help="print the result as JSON")
+    ap.add_argument("--exit-distance", type=float, default=8.0,
+                    help="metres from an exit that counts as near one (default 8)")
+    args = ap.parse_args(argv)
+    try:
+        with open(args.seating, encoding="utf-8") as fh:
+            plan = load(json.load(fh))
+    except (OSError, ValueError) as e:  # BadInput and JSONDecodeError are ValueErrors
+        print(f"FAIL cannot read {args.seating}: {e}")
+        return 2
+    r = check(plan, args.exit_distance)
+    if args.json:
+        print(json.dumps({"pass": not r["fails"], "fails": r["fails"], "warns": r["warns"],
+                          "seated": r["seated"], "guests": r["guests"], "tables": table_rows(plan, r)}, indent=1))
+    else:
+        print(report(plan, r), end="")
+    if args.svg:
+        with open(args.svg, "w", encoding="utf-8") as fh:
+            fh.write(svg(plan, 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/seating-plan/templates/seating.json

@@ -0,0 +1,28 @@
+{
+  "room": {"width": 14, "depth": 10},
+  "exits": [[0, 5], [14, 9]],
+  "tables": [
+    {"id": "Head", "capacity": 8, "shape": "rect", "at": [7, 1.5], "accessible": true},
+    {"id": "T1", "capacity": 10, "shape": "round", "at": [3, 5], "accessible": true},
+    {"id": "T2", "capacity": 10, "shape": "round", "at": [7, 5.5]},
+    {"id": "T3", "capacity": 10, "shape": "round", "at": [11, 5]}
+  ],
+  "guests": [
+    {"id": "g1", "name": "Mira Osei", "party": "Couple"},
+    {"id": "g2", "name": "Tom Hale", "party": "Couple"},
+    {"id": "g3", "name": "Ruth Osei", "party": "Osei", "needs": ["wheelchair"], "dietary": "vegetarian"},
+    {"id": "g4", "name": "Kwame Osei", "party": "Osei"},
+    {"id": "g5", "name": "Dana Hale", "party": "Hale", "needs": ["near exit"]},
+    {"id": "g6", "name": "Pete Hale", "party": "Hale", "dietary": "gluten-free"},
+    {"id": "g7", "name": "Lena Brook", "party": ""}
+  ],
+  "together": [["g3", "g4"]],
+  "apart": [["g4", "g6"]],
+  "fixed": {"g1": "Head", "g2": "Head"},
+  "assignments": {
+    "Head": ["g1", "g2"],
+    "T1": ["g3", "g4", "g7"],
+    "T2": [],
+    "T3": ["g5", "g6"]
+  }
+}

package/packs/experience-design/pack.json

@@ -57,6 +57,11 @@
         "you_get": "A blueprint table and Mermaid diagram with fail points, waits, pains traced to causes, and 2–3 ranked fixes.",
         "decide": "Which fix becomes committed work."
       },
+      {
+        "skill": "locale-check",
+        "you_do": "Hand over the source strings and the translated files before release.",
+        "you_get": "Whether the release is safe to ship, and each failure by locale with the corrected string or a note for the translator."
+      },
       {
         "skill": "doc-critique",
         "you_do": "Run it on any of the specs before you share them.",

package/packs/experience-design/skills/locale-check/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: locale-check
+description: Check a product's translations against the source strings before they ship — every key present, every placeholder ({name}, %s, %1$d, ICU plural and select) carried over intact, the plural forms each language needs, markup tags balanced, and strings over their character budget — with a script that reads JSON, ARB, gettext .po, Android strings.xml and iOS .strings, and lists each problem with its key and locale. Use when someone asks to "check the translations", "QA these locale files", "will the German fit", "why does the French build crash on this string", or hands over locale files before a release.
+---
+
+# locale-check
+
+Decides whether a set of translated string files is safe to ship, and says exactly what to fix
+in each one. The defects that matter are mechanical and easy to miss by reading: a `{count}`
+dropped from one German string, Polish shipped with two plural forms where it needs four, an
+Arabic file missing `zero`, two printf arguments swapped in French, an apostrophe that stops an
+Android build. A read-through of 500 strings misses them; a check of every string doesn't. This
+skill does not write the source strings (that's `ux-writing`) or the page content around them
+(that's `content-design`), and it does not translate.
+
+## How to respond
+
+1. **Run the check on the source and every target before reading anything.** The source is
+   the language the product is written in, often `en`; the targets are the translations.
+
+   ```bash
+   python3 "${CLAUDE_SKILL_DIR}/scripts/locale_check.py" en.json de.json fr.json pl.json --json
+   # Other IDEs (from the skill folder)
+   python3 scripts/locale_check.py values/strings.xml values-ar/strings.xml values-fr/strings.xml
+   python3 scripts/locale_check.py messages.pot fr.po --budget budget.json
+   ```
+
+   It reads JSON (i18next `key_one` / `key_other` plurals included), ARB, `.po` against a
+   `.pot` or source `.po`, Android `strings.xml`, iOS `.strings` and `.stringsdict`. The locale
+   comes from the path (`de.json`, `values-fr/`, `fr.lproj`); when a path doesn't say, pass
+   `--locale` once per target, in order. A file in another format (XLIFF, YAML, a
+   spreadsheet) is read by hand: list its keys, placeholders and plural forms, and apply the
+   rules below to every row. Exit 0 means no failures, 1 failures, 2 a file it couldn't read.
+
+2. **Read the source string beside every finding, and beside every reordered placeholder.**
+   The check matches tokens, not meaning, so a clean result is not the answer.
+   - **A reorder is valid syntax and can still be wrong.** For every target whose numbered
+     placeholders (`%2$s … %1$s`, `{1} … {0}`) appear in a different order from the source,
+     read both sentences and confirm each argument still fills the same role. ✅ *"de %2$s a
+     %1$s" for "from %1$s to %2$s" sends the parcel the wrong way: a failure, with the fix
+     "de %1$s a %2$s".* A reorder that only follows the target's word order is fine.
+   - **Read in full the strings on any screen the person names** (checkout, payment, sign-in),
+     whatever the check says.
+   A placeholder that moved is fine only once its role is confirmed; one that vanished is not. A select keyword is code, so
+   `male` translated as `masculin` breaks the branch. A plural form that exists but says the
+   wrong number is still wrong. Confirm each finding against the source before reporting it.
+
+3. **Rank by what breaks first.**
+   1. **The build or the app crashes:** a file that doesn't parse, an ICU message that
+      doesn't parse, an Android apostrophe without a backslash, printf arguments whose types
+      changed or swapped, a missing key the code reads.
+   2. **The screen shows the wrong thing:** a dropped placeholder, plural forms the language
+      needs but doesn't have, markup that doesn't balance.
+   3. **The screen overflows:** strings over their budget.
+   4. **Style:** warnings such as possibly untranslated, punctuation dropped, a stale key.
+   A warning is reported as a warning. It never sits in the failures table.
+
+4. **Give the corrected string when the fix is mechanical, and only then.**
+   - **Restore a dropped placeholder** where the sentence's grammar puts it, and say so:
+     ✅ *`"Hallo, {name}!"` — restored `{name}` after the greeting, as in the source.*
+   - **Number swapped printf arguments** so the order can stay as the translator wrote it:
+     ✅ *`"Vous avez %2$d messages, %1$s"`.*
+   - **Add a missing plural form** by repeating the language's pattern only when the
+     form is regular and you are sure of it (Polish `few` for 2–4: *"2 pliki"*). Otherwise
+     mark it for a translator with the numbers it covers: *"pl `few` (2–4, 22–24, …):
+     needs a translator"*.
+   - **Escape** an Android apostrophe as `\'`.
+   - **Never write new translated text silently.** An untranslated string, a wrong meaning or a
+     missing key goes to a translator with the source string, the locale and the slot. When you
+     do suggest wording for a missing key, label it *suggested, for a translator to confirm*.
+
+5. **Change no file unless asked.** Offer a patched copy of each target with the mechanical
+   fixes applied, written beside the original (`de.fixed.json`), and list what it changed.
+
+6. **Measure every length the person gives you.** A limit stated in the request ("buttons
+   max 24 characters", "the German must fit a 120 px tab") is a budget: pass it with
+   `--budget`, or count the characters of every string it covers, and report each one over
+   with its length and the limit. Never say a string fits without counting it. Only when no
+   limit is given anywhere, say in one line that lengths weren't checked, and name the slots
+   most at risk (buttons, tabs, toasts).
+   A format read by hand, and a locale whose plural rules aren't known, are named too.
+
+7. **Reply in this order.** First line: whether the release is safe to ship, as a plain yes
+   or no, with the count of failures by locale, counted from the table below it so the two
+   agree. Then the failures, in one table per locale
+   or one table with a locale column: key, what breaks, source, target, and the corrected
+   string or *needs a translator*. Then the warnings, shorter. Then what wasn't checked. Write
+   for the person shipping the release: no tool names, no script output pasted, no paths
+   inside this skill's folder. Asked which string caused a crash, name every string that would
+   cause it, and pick one only when the evidence (a log, a stack trace, a screen) says which.
+
+**Non-interactive runs:** a limit in the request is a budget (step 6); with none anywhere,
+there is no length check, and the reply says so. A missing
+locale code is inferred from the strings' script and language, tagged `[assumption]`, and
+listed first. Emit `BLOCKED: need the source strings and at least one translation` only when
+there is no source file or no target at all; with one of several targets unreadable, check the
+rest and report that one as a failure.
+
+## Useful references in this skill
+
+- [`scripts/locale_check.py`](scripts/locale_check.py) — every check in this skill, with CLDR plural categories for about 60 languages and gettext `nplurals` (stdlib only)
+- [`examples/settings-release.md`](examples/settings-release.md) — worked example: a settings screen in German, Russian and Arabic, with translated select keywords, missing Russian plurals and a toggle over budget
+
+## Quality bar
+
+- **Every target is checked, every finding read against its source string.** A count with no check behind it is a guess.
+- **Crashes first, then wrong screens, then overflow, then style.** The reader fixes in that order.
+- **A mechanical fix comes with the corrected string;** a wording fix goes to a translator.
+- **Plural forms are judged by the target language's rules,** not the source's: Polish needs four, Arabic six, Japanese one.
+- **Nothing is translated or edited unasked,** and nothing is cut: a dubious string is flagged, not removed.
+- **Every reordered placeholder is read for meaning,** not passed because the syntax is valid.
+- **Every length limit the person states is measured.** "It fits" always has a count behind it.
+- **What wasn't checked is said in one line.**
+
+## When to use this skill
+
+- ✅ "Check these translations before the release" with locale files
+- ✅ "Why does the French build crash on this string?"
+- ✅ "Will the German fit on the buttons?" with a budget or the widths
+- ✅ "QA the strings the agency sent back"
+- ✅ A pull request that adds or updates locale files
+
+## When NOT to use this skill
+
+- ❌ Writing the source strings, button labels or error messages: that's `ux-writing`
+- ❌ Writing or restructuring the page content itself: that's `content-design`
+- ❌ "Translate this into French": that's translation, and this skill only checks it
+
+## Anti-patterns to avoid
+
+- ❌ **Reading the files instead of checking them.** A dropped `{count}` in string 312 of 500 is invisible to a skim.
+- ❌ **Judging plurals by the source.** English has two forms; shipping Russian with two is the bug.
+- ❌ **"Fixing" a translation by rewriting it.** Restore the placeholder; leave the wording to the translator.
+- ❌ **Calling a missing key a warning.** The code reads it; the user sees the raw key or the source text.
+- ❌ **Calling `masculin` a good translation of `male`.** Select keywords are code, never text.
+- ❌ **"Lengths look fine" with no budget.** Say they weren't checked.
+- ❌ **Trusting a clean check on a reordered sentence.** `%2$s … %1$s` passes the syntax and can still swap the sender and the receiver.
+- ❌ **Naming one string as the crash on a guess.** Name every candidate until the evidence picks one.
+- ❌ **Pasting the raw report.** Lead with the ship decision and the fixes, by locale.

package/packs/experience-design/skills/locale-check/evals/eval_queries.json

@@ -0,0 +1,38 @@
+[
+  {
+    "query": "check these translation files before we release",
+    "should_trigger": true
+  },
+  {
+    "query": "QA the locale JSON the agency sent back for German and Polish",
+    "should_trigger": true
+  },
+  {
+    "query": "why does the French Android build crash on this strings.xml",
+    "should_trigger": true
+  },
+  {
+    "query": "will the German strings fit on the buttons? here are the files and the limits",
+    "should_trigger": true
+  },
+  {
+    "query": "are the plural forms right in our ru.po and ar.json?",
+    "should_trigger": true
+  },
+  {
+    "query": "translate these button labels into French",
+    "should_trigger": false
+  },
+  {
+    "query": "write the error messages for our checkout form",
+    "should_trigger": false
+  },
+  {
+    "query": "rewrite our help page in plain English",
+    "should_trigger": false
+  },
+  {
+    "query": "make the wording consistent across the settings screens",
+    "should_trigger": false
+  }
+]