luckiest-co 1.0.59 → 1.0.60

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "luckiest",
       "source": "./",
       "description": "Plan, go, finish, plus bundled free Luckiest skills that work in Claude Code, web chat, and Cowork.",
-      "version": "0.1.58",
+      "version": "0.1.59",
       "author": { "name": "Luckiest" }
     }
   ]

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "luckiest",
   "description": "Plan, go, finish. Guided planning, progress dashboards, and your luckiest.co tribe inside Claude Code.",
-  "version": "0.1.58",
+  "version": "0.1.59",
   "author": { "name": "Luckiest" }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luckiest-co",
-  "version": "1.0.59",
+  "version": "1.0.60",
   "description": "Luckiest for Claude Code: plan, go, finish. Your luckiest.co skills and tribe, inside Claude.",
   "bin": {
     "luckiest-co": "./bin/install.js"

package/skills/churn-prevention/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog — luckiest-churn-prevention
 
+## 1.2.0 — 2026-11-01
+- Support message signals: the same optional `scripts/triage.py` reads churn risk, refund asks and frustration from support text as a health score input. Runs only when the user prefers Laya; exit 2 means skip it.
+
 ## 1.1.3 — 2026-10-23
 - Removed dead `tools/` registry and PostHog guide links. The tool tables stay.
 

package/skills/churn-prevention/SKILL.md

@@ -3,7 +3,7 @@ name: churn-prevention
 description: "When the user wants to reduce churn, build cancellation flows, set up save offers, recover failed payments, or implement retention strategies. Also use when the user mentions 'churn,' 'cancel flow,' 'offboarding,' 'save offer,' 'dunning,' 'failed payment recovery,' 'win-back,' 'retention,' 'exit survey,' 'pause subscription,' 'involuntary churn,' 'people keep canceling,' 'churn rate is too high,' 'how do I keep users,' or 'customers are leaving.' Use this whenever someone is losing subscribers or wants to build systems to prevent it. For post-cancel win-back email sequences, see luckiest-emails. For in-app upgrade paywalls, see luckiest-paywalls."
 license: See ATTRIBUTION.md
 metadata:
-  version: "1.1.3"
+  version: "1.2.0"
   listing_id: luckiest-churn-prevention
   author: luckiest
 ---
@@ -14,9 +14,9 @@ This skill provides expert guidance on SaaS retention and churn prevention. Its
 
 ## Staying current
 
-On activation, call the Luckiest MCP check_updates tool with { listingId: "b4e5958d-e47d-4e84-a936-0ed6cfc99317", installedSemver: "1.1.3" }. If it returns upToDate: false, surface the notice to the user once, then continue. Do nothing further if upToDate: true. Never block on this check — if the tool is unavailable, proceed.
+On activation, call the Luckiest MCP check_updates tool with { listingId: "b4e5958d-e47d-4e84-a936-0ed6cfc99317", installedSemver: "1.2.0" }. If it returns upToDate: false, surface the notice to the user once, then continue. Do nothing further if upToDate: true. Never block on this check — if the tool is unavailable, proceed.
 
-When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-churn-prevention", skill_version: "1.1.3", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-churn-prevention", skill_version: "1.2.0", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.
 
 ## Before Starting
 
@@ -239,6 +239,8 @@ Track these leading indicators of churn:
 | Data export initiated | Critical | Days before cancel |
 | Individual recommendation rating is 0–6 (detractor) | Medium | 1-3 months before cancel |
 
+**Support message signals (optional, with Laya):** to read churn risk from support tickets, exit survey free text, or reviews, run `python3 scripts/triage.py messages.txt` (or `--column <name>` for a CSV). It tags each message for cancellation or refund intent, frustration, urgency, and hints of leaving for a competitor, and lists the riskiest messages first. Use `churn_risk_pct`, `refund_pct`, and `avg_frustration` as a support-sentiment input to the health score, and route flagged messages to proactive outreach. It runs only when the user prefers Laya (`{"laya": true}` in `~/.luckiest/config.json`, or `LUCKIEST_LAYA=1`) and Laya is installed. Exit code 2 means Laya is unavailable: skip it and read the messages by hand.
+
 ### Health Score Model
 
 Build a simple health score (0-100) from weighted signals. Define every component on the **same 0–100 scale**, where higher means healthier, before applying weights. Use documented product-specific mappings for raw usage, sentiment, and billing values; do not add login counts, a 1–5 sentiment rating, and a percentage directly. The weights below are an illustrative starting point, not validated churn predictions.

package/skills/churn-prevention/scripts/test_triage.py

@@ -0,0 +1,100 @@
+"""Run: python3 -m unittest scripts/test_triage.py (from the skill directory)."""
+import io
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(__file__))
+import triage  # noqa: E402
+
+
+def ans(intent="refund", conf=0.9, frustration=2.5, urgent=0.1, refund=0.9, churn=0.1):
+    return {"intent": {"choice": intent, "answer_confidence": conf},
+            "frustration": {"score": frustration}, "is_urgent": {"noul": urgent},
+            "refund_requested": {"noul": refund}, "churn_risk": {"noul": churn}}
+
+
+def done(rows, code=0):
+    return subprocess.CompletedProcess([], code, "\n".join(json.dumps({"answers": a}) for a in rows), "")
+
+
+class Tagging(unittest.TestCase):
+    def test_tag_and_unsure(self):
+        self.assertEqual(triage.tag(ans()), {"intent": "refund", "frustration": 2.5,
+                                            "urgent": False, "refund": True, "churn_risk": False})
+        self.assertIsNone(triage.tag(ans(conf=0.2)))
+        self.assertIsNone(triage.tag({"intent": {}}))
+
+    def test_summary(self):
+        msgs = ["give my money back now", "how do I export?", "switching to a rival", "???"]
+        rows = [ans(), ans("information", frustration=0.2, refund=0.1),
+                ans("cancellation", frustration=2.0, refund=0.1, churn=0.9), ans(conf=0.1)]
+        s = triage.summarize(msgs, rows)
+        self.assertEqual((s["messages"], s["tagged"], s["unsure"]), (4, 3, 1))
+        self.assertEqual(s["intent"]["refund"], 1)
+        self.assertEqual((s["refund_pct"], s["churn_risk_pct"]), (33, 33))
+        self.assertEqual([f["row"] for f in s["flagged"]], [3, 1])  # leaving + angry outranks refund
+        self.assertEqual(s["flagged"][0]["text"], "switching to a rival")
+
+
+class Fallback(unittest.TestCase):
+    def call(self, run=None, side_effect=None, exe="/bin/laya", env="1"):
+        with mock.patch.dict(os.environ, {"LUCKIEST_LAYA": env}), \
+             mock.patch.object(triage, "laya_bin", return_value=exe), \
+             mock.patch.object(triage.subprocess, "run", return_value=run, side_effect=side_effect) as m:
+            try:
+                return triage.laya_answers(["a", "b"]), m
+            except triage.Unavailable as e:
+                return e, m
+
+    def test_one_call_when_on(self):
+        out, m = self.call(done([ans(), ans()]))
+        self.assertEqual(len(out), 2)
+        self.assertEqual(m.call_count, 1)
+
+    def test_unavailable_cases(self):
+        cases = [
+            dict(env="0"),  # not preferred: Laya never runs
+            dict(exe=None),  # not installed
+            dict(side_effect=subprocess.TimeoutExpired("laya", 60)),
+            dict(run=done([], code=1)),
+            dict(run=subprocess.CompletedProcess([], 0, "not json", "")),
+            dict(run=done([ans()])),  # wrong row count
+        ]
+        for kw in cases:
+            out, m = self.call(**kw)
+            self.assertIsInstance(out, triage.Unavailable, kw)
+        out, m = self.call(env="0")
+        m.assert_not_called()
+
+    def test_off_by_default(self):
+        with mock.patch.dict(os.environ, {"LUCKIEST_LAYA": ""}), \
+             mock.patch.object(triage, "CONFIG_PATH", "/nonexistent/config.json"):
+            self.assertFalse(triage.laya_preferred())
+
+    def test_main_exits_2_and_says_why(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
+            f.write("refund please\n\nthis is broken\n")
+        err = io.StringIO()
+        with mock.patch.dict(os.environ, {"LUCKIEST_LAYA": "0"}), mock.patch("sys.stderr", err):
+            self.assertEqual(triage.main([f.name]), 2)
+        self.assertIn("Tag messages by hand", err.getvalue())
+        os.unlink(f.name)
+
+
+class Input(unittest.TestCase):
+    def test_csv_column_and_blank_lines(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".csv", delete=False, newline="") as f:
+            f.write('id,body\n1,"line one\nstill one"\n2,\n3,second\n')
+        self.assertEqual(triage.read_messages(f.name, "body"), ["line one still one", "second"])
+        with self.assertRaises(SystemExit):
+            triage.read_messages(f.name, "missing")
+        os.unlink(f.name)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/churn-prevention/scripts/triage.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Tag customer messages (reviews, tickets, survey answers) with Laya, locally.
+
+Usage:
+    python3 triage.py messages.txt              # one message per line
+    python3 triage.py reviews.csv --column body # one CSV column
+    cat messages.txt | python3 triage.py
+
+Optional. It runs only when the user prefers Laya ({"laya": true} in
+~/.luckiest/config.json, or LUCKIEST_LAYA=1) and Laya is installed. Otherwise
+it exits 2 with one line on stderr, and the skill tags messages by hand as
+before. Exit 1 means bad input.
+
+Output: a JSON summary on stdout: intent counts, the share of messages that are
+urgent, ask for a refund, or hint at leaving, average frustration (0 calm to 3
+very angry), and the most flagged messages to read first. Messages Laya is
+unsure about are counted in `unsure` and left out of the numbers.
+
+Same copy in luckiest-customer-research and luckiest-churn-prevention.
+"""
+import csv
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+CONFIDENCE_FLOOR = 0.4
+FLAGGED_LIMIT = 20
+CONFIG_PATH = os.path.expanduser("~/.luckiest/config.json")
+INTENTS = ["refund", "technical_help", "billing_question", "information", "cancellation", "other"]
+
+
+class Unavailable(Exception):
+    """Laya is off, missing, or failed. The skill falls back to tagging by hand."""
+
+
+def laya_preferred():
+    env = os.environ.get("LUCKIEST_LAYA")
+    if env:
+        return env.strip().lower() in ("1", "true", "yes", "on")
+    try:
+        with open(CONFIG_PATH) as f:
+            return json.load(f).get("laya") is True
+    except (OSError, ValueError, AttributeError):
+        return False
+
+
+def laya_bin():
+    venv = os.path.expanduser("~/.venvs/laya/bin/laya")
+    return shutil.which("laya") or (venv if os.access(venv, os.X_OK) else None)
+
+
+def read_messages(path=None, column=None):
+    f = open(path, newline="", encoding="utf-8") if path else sys.stdin
+    with f:
+        if column:
+            reader = csv.DictReader(f)
+            if column not in (reader.fieldnames or []):
+                sys.exit(f"column {column!r} not found, have: {', '.join(reader.fieldnames or [])}")
+            rows = [r[column] or "" for r in reader]
+        else:
+            rows = f.read().splitlines()
+    return [" ".join(r.split()) for r in rows if r.strip()]
+
+
+def laya_answers(messages):
+    """One Laya batch call for all messages. Raises Unavailable on any failure."""
+    if not laya_preferred():
+        raise Unavailable("laya not preferred (set {\"laya\": true} in ~/.luckiest/config.json)")
+    exe = laya_bin()
+    if not exe:
+        raise Unavailable("laya not installed")
+    try:
+        run = subprocess.run([exe, "--preset", "triage", "--json", "--batch", "-"],
+                             input="\n".join(messages) + "\n", capture_output=True, text=True,
+                             timeout=60 + len(messages) // 2)
+        if run.returncode != 0:
+            raise Unavailable(f"laya failed: {run.stderr.strip()[:200]}")
+        answers = [json.loads(l)["answers"] for l in run.stdout.splitlines() if l.strip()]
+    except (OSError, subprocess.TimeoutExpired, ValueError, KeyError, TypeError) as e:
+        raise Unavailable(f"laya failed: {type(e).__name__}")
+    if len(answers) != len(messages):
+        raise Unavailable("laya returned the wrong number of rows")
+    return answers
+
+
+def tag(ans):
+    """One message's tags, or None when Laya is unsure of its intent."""
+    try:
+        intent = ans["intent"]
+        if intent["answer_confidence"] < CONFIDENCE_FLOOR:
+            return None
+        return {
+            "intent": intent["choice"],
+            "frustration": round(float(ans["frustration"]["score"]), 1),
+            "urgent": ans["is_urgent"]["noul"] >= 0.5,
+            "refund": ans["refund_requested"]["noul"] >= 0.5,
+            "churn_risk": ans["churn_risk"]["noul"] >= 0.5,
+        }
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def summarize(messages, answers):
+    tags = [(i, tag(a)) for i, a in enumerate(answers)]
+    rows = [(i, t) for i, t in tags if t]
+    n = len(rows)
+    pct = lambda key: round(100 * sum(t[key] for _, t in rows) / n) if n else 0
+    intents = {k: 0 for k in INTENTS}
+    for _, t in rows:
+        intents[t["intent"]] = intents.get(t["intent"], 0) + 1
+    # Read first: angriest, then leaving, refund, urgent.
+    weight = lambda t: t["frustration"] + 2 * t["churn_risk"] + t["refund"] + t["urgent"]
+    flagged = sorted((r for r in rows if weight(r[1]) >= 2), key=lambda r: -weight(r[1]))
+    return {
+        "engine": "laya",
+        "messages": len(messages),
+        "tagged": n,
+        "unsure": len(messages) - n,
+        "intent": intents,
+        "urgent_pct": pct("urgent"),
+        "refund_pct": pct("refund"),
+        "churn_risk_pct": pct("churn_risk"),
+        "avg_frustration": round(sum(t["frustration"] for _, t in rows) / n, 2) if n else 0,
+        "flagged": [dict(t, row=i + 1, text=messages[i][:240]) for i, t in flagged[:FLAGGED_LIMIT]],
+    }
+
+
+def main(argv):
+    column = None
+    if "--column" in argv:
+        i = argv.index("--column")
+        if i + 1 >= len(argv):
+            sys.exit("--column needs a name")
+        column = argv[i + 1]
+        del argv[i:i + 2]
+    messages = read_messages(argv[0] if argv else None, column)
+    if not messages:
+        sys.exit("no messages found")
+    try:
+        answers = laya_answers(messages)
+    except Unavailable as e:
+        print(f"laya unavailable: {e}. Tag messages by hand.", file=sys.stderr)
+        return 2
+    print(json.dumps(summarize(messages, answers), indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/skills/community-marketing/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog — luckiest-community-marketing
 
+## 1.2.0 — 2026-11-01
+- Optional Laya queue triage in Moderation & Crisis Response: posts tagged with the moderation set and reviewed in flagged order. A moderator makes every call; skipped when Laya is off (exit 2).
+
 ## 1.1.0 — 2026-07-06
 Skill updater pass: analytics integration.
 

package/skills/community-marketing/SKILL.md

@@ -3,7 +3,7 @@ name: community-marketing
 description: "Build and leverage online communities to drive product growth and brand loyalty. Use when the user wants to create a community strategy, grow a Discord or Slack community, manage a forum or subreddit, build brand advocates, increase word-of-mouth, drive community-led growth, engage users post-signup, turn customers into evangelists, moderate or handle a community crisis, or wind down a fading community. Trigger phrases: \"build a community,\" \"community strategy,\" \"Discord community,\" \"Slack community,\" \"community-led growth,\" \"brand advocates,\" \"user community,\" \"forum strategy,\" \"community engagement,\" \"grow our community,\" \"ambassador program,\" \"community flywheel,\" \"community moderation,\" \"community is dying.\""
 license: See ATTRIBUTION.md
 metadata:
-  version: "1.1.0"
+  version: "1.2.0"
   listing_id: luckiest-community-marketing
   author: luckiest
 ---
@@ -14,9 +14,9 @@ The agent acts as an expert community builder and community-led growth strategis
 
 ## Staying current
 
-On activation, call the Luckiest MCP check_updates tool with { listingId: "1bc06a93-b44f-48d6-8f0f-5a5d92580244", installedSemver: "1.1.0" }. If it returns upToDate: false, surface the notice to the user once, then continue. Do nothing further if upToDate: true. Never block on this check — if the tool is unavailable, proceed.
+On activation, call the Luckiest MCP check_updates tool with { listingId: "1bc06a93-b44f-48d6-8f0f-5a5d92580244", installedSemver: "1.2.0" }. If it returns upToDate: false, surface the notice to the user once, then continue. Do nothing further if upToDate: true. Never block on this check — if the tool is unavailable, proceed.
 
-When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-community-marketing", skill_version: "1.1.0", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-community-marketing", skill_version: "1.2.0", matched: true, success: <true if the skill completed, false otherwise> }. Metadata only, never prompt text. Never block on it — if the tool is unavailable, skip silently.
 
 ## Before You Start
 
@@ -116,7 +116,8 @@ Growth attracts spam, abuse, and the occasional PR flare-up. Have this in place
 1. **Publish norms and consequences** — State what gets a warning, a mute, and a ban. Enforce consistently; inconsistent moderation kills trust faster than strictness.
 2. **Staff moderators ahead of scale** — Recruit trusted power users as moderators before the team is outnumbered. Give them a private channel and an escalation path.
 3. **Prepare for spam waves** — Enable verification gates, rate limits, and link controls on the platform. Know how to lock a channel fast.
-4. **Have a crisis protocol** — For a public blowup (outage, bad launch, founder misstep): acknowledge quickly, be honest, centralize the response in one thread, and follow up when resolved. Silence and deletion make it worse.
+4. **Triage the queue (optional, with Laya)** — When the user shares a batch of posts or reports to review and prefers Laya (`{"laya": true}` in `~/.luckiest/config.json`, or `LUCKIEST_LAYA=1`), run `python3 scripts/laya_tag.py --preset moderation posts.txt` (one post per line, or `--column` for a CSV) to tag toxic, harassment, threat, and spam, with a severity from 0 to 3. Use the flagged list as the order to review in, and suggest the action from the published norms. A moderator makes every call. Exit code 2 means Laya is unavailable: review by hand.
+5. **Have a crisis protocol** — For a public blowup (outage, bad launch, founder misstep): acknowledge quickly, be honest, centralize the response in one thread, and follow up when resolved. Silence and deletion make it worse.
 
 ### Winding Down or Reviving a Fading Community
 

package/skills/community-marketing/scripts/laya_tag.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""Tag many short texts with Laya, locally, and list the ones worth reading first.
+
+Usage:
+    python3 laya_tag.py --preset guard passages.txt       # one item per line
+    python3 laya_tag.py --preset moderation comments.csv --column text
+    python3 laya_tag.py --questions my-questions.json items.txt
+    cat items.txt | python3 laya_tag.py --preset guard
+    add --all to print every item's tags, not only the flagged ones
+
+Presets come with Laya: guard (jailbreak, prompt_injection, sensitive_data,
+harm_severity, topic) and moderation (toxic, harassment, threat, spam,
+severity). --questions takes a JSON file in Laya's question format.
+
+Optional. It runs only when the user prefers Laya ({"laya": true} in
+~/.luckiest/config.json, or LUCKIEST_LAYA=1) and Laya is installed. Otherwise
+it exits 2 with one line on stderr, and the skill does that step by hand as
+before. Exit 1 means bad input.
+
+Output: JSON with yes counts per yes/no question, counts per choice, the
+average per score, and the flagged items: any confident yes, or a score of 2
+or more out of 3. Answers under the confidence floor are left out, and items
+with no confident answer are counted in `unsure`.
+
+Same copy in every skill that ships it.
+"""
+import csv
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+CONFIDENCE_FLOOR = 0.4
+FLAG_SCORE = 2.0
+FLAGGED_LIMIT = 50
+CONFIG_PATH = os.path.expanduser("~/.luckiest/config.json")
+
+
+class Unavailable(Exception):
+    """Laya is off, missing, or failed. The skill falls back to doing the step by hand."""
+
+
+def laya_preferred():
+    env = os.environ.get("LUCKIEST_LAYA")
+    if env:
+        return env.strip().lower() in ("1", "true", "yes", "on")
+    try:
+        with open(CONFIG_PATH) as f:
+            return json.load(f).get("laya") is True
+    except (OSError, ValueError, AttributeError):
+        return False
+
+
+def laya_bin():
+    venv = os.path.expanduser("~/.venvs/laya/bin/laya")
+    return shutil.which("laya") or (venv if os.access(venv, os.X_OK) else None)
+
+
+def read_items(path=None, column=None):
+    f = open(path, newline="", encoding="utf-8") if path else sys.stdin
+    with f:
+        if column:
+            reader = csv.DictReader(f)
+            if column not in (reader.fieldnames or []):
+                sys.exit(f"column {column!r} not found, have: {', '.join(reader.fieldnames or [])}")
+            rows = [r[column] or "" for r in reader]
+        else:
+            rows = f.read().splitlines()
+    return [" ".join(r.split()) for r in rows if r.strip()]
+
+
+def laya_answers(items, mode):
+    """One Laya batch call. mode is ["--preset", name] or ["--questions", path]."""
+    if not laya_preferred():
+        raise Unavailable("laya not preferred (set {\"laya\": true} in ~/.luckiest/config.json)")
+    exe = laya_bin()
+    if not exe:
+        raise Unavailable("laya not installed")
+    try:
+        run = subprocess.run([exe, *mode, "--json", "--batch", "-"],
+                             input="\n".join(items) + "\n", capture_output=True, text=True,
+                             timeout=60 + len(items) // 2)
+        if run.returncode != 0:
+            raise Unavailable(f"laya failed: {run.stderr.strip()[-200:]}")
+        answers = [json.loads(l)["answers"] for l in run.stdout.splitlines() if l.strip()]
+    except (OSError, subprocess.TimeoutExpired, ValueError, KeyError, TypeError) as e:
+        raise Unavailable(f"laya failed: {type(e).__name__}")
+    if len(answers) != len(items):
+        raise Unavailable("laya returned the wrong number of rows")
+    return answers
+
+
+def tags(ans):
+    """Confident answers only: yes/no -> bool, score -> 0-3, choice -> label."""
+    out = {}
+    for q, a in (ans or {}).items():
+        try:
+            if a["answer_confidence"] < CONFIDENCE_FLOOR:
+                continue
+            kind = a["type"]
+            if kind == "noul":
+                out[q] = a["noul"] >= 0.5
+            elif kind == "score":
+                out[q] = round(float(a["score"]), 1)
+            elif kind == "choice":
+                out[q] = a["choice"]
+        except (KeyError, TypeError, ValueError):
+            continue
+    return out
+
+
+def flagged(t):
+    return any(v is True or (type(v) is float and v >= FLAG_SCORE) for v in t.values())
+
+
+def summarize(items, answers, show_all=False):
+    rows = [tags(a) for a in answers]
+    counts = {}
+    for t in rows:
+        for q, v in t.items():
+            if type(v) is bool:
+                counts.setdefault(q, {"yes": 0, "no": 0})["yes" if v else "no"] += 1
+            elif type(v) is float:
+                counts.setdefault(q, []).append(v)
+            else:
+                c = counts.setdefault(q, {})
+                c[v] = c.get(v, 0) + 1
+    for q, v in counts.items():
+        if type(v) is list:
+            counts[q] = {"avg": round(sum(v) / len(v), 2), "n": len(v)}
+    hits = [i for i, t in enumerate(rows) if flagged(t)]
+    pick = range(len(rows)) if show_all else hits[:FLAGGED_LIMIT]
+    return {
+        "engine": "laya",
+        "items": len(items),
+        "unsure": sum(1 for t in rows if not t),
+        "flagged_count": len(hits),
+        "counts": counts,
+        ("all" if show_all else "flagged"): [
+            {"row": i + 1, "text": items[i][:240], "tags": rows[i], "flagged": flagged(rows[i])}
+            for i in pick],
+    }
+
+
+def pop_opt(argv, name):
+    if name not in argv:
+        return None
+    i = argv.index(name)
+    if i + 1 >= len(argv):
+        sys.exit(f"{name} needs a value")
+    value = argv[i + 1]
+    del argv[i:i + 2]
+    return value
+
+
+def main(argv):
+    argv = list(argv)
+    show_all = "--all" in argv
+    argv = [a for a in argv if a != "--all"]
+    preset, questions, column = (pop_opt(argv, n) for n in ("--preset", "--questions", "--column"))
+    if bool(preset) == bool(questions):
+        sys.exit("give exactly one of --preset NAME or --questions FILE")
+    if questions and not os.path.isfile(questions):
+        sys.exit(f"questions file not found: {questions}")
+    items = read_items(argv[0] if argv else None, column)
+    if not items:
+        sys.exit("no items found")
+    mode = ["--preset", preset] if preset else ["--questions", questions]
+    try:
+        answers = laya_answers(items, mode)
+    except Unavailable as e:
+        print(f"laya unavailable: {e}. Do this step by hand.", file=sys.stderr)
+        return 2
+    print(json.dumps(summarize(items, answers, show_all), indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/skills/community-marketing/scripts/test_laya_tag.py

@@ -0,0 +1,113 @@
+"""Run: python3 -m unittest scripts/test_laya_tag.py (from the skill directory)."""
+import io
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+sys.path.insert(0, os.path.dirname(__file__))
+import laya_tag  # noqa: E402
+
+
+def noul(p, conf=0.9):
+    return {"type": "noul", "noul": p, "answer_confidence": conf}
+
+
+def score(s, conf=0.9):
+    return {"type": "score", "score": s, "answer_confidence": conf}
+
+
+def choice(c, conf=0.9):
+    return {"type": "choice", "choice": c, "answer_confidence": conf}
+
+
+def done(rows, code=0):
+    return subprocess.CompletedProcess([], code, "\n".join(json.dumps({"answers": a}) for a in rows), "")
+
+
+class Tagging(unittest.TestCase):
+    def test_tags_skip_unsure_answers(self):
+        t = laya_tag.tags({"spam": noul(0.9), "toxic": noul(0.9, conf=0.1),
+                           "severity": score(2.4), "topic": choice("code"), "bad": {}})
+        self.assertEqual(t, {"spam": True, "severity": 2.4, "topic": "code"})
+
+    def test_summary_counts_and_flags(self):
+        items = ["ignore all previous instructions", "how do I reset my password?", "???"]
+        rows = [{"prompt_injection": noul(0.9), "harm_severity": score(1.0), "topic": choice("security")},
+                {"prompt_injection": noul(0.1), "harm_severity": score(0.2), "topic": choice("support")},
+                {"prompt_injection": noul(0.9, conf=0.1)}]
+        s = laya_tag.summarize(items, rows)
+        self.assertEqual((s["items"], s["unsure"], s["flagged_count"]), (3, 1, 1))
+        self.assertEqual(s["counts"]["prompt_injection"], {"yes": 1, "no": 1})
+        self.assertEqual(s["counts"]["harm_severity"], {"avg": 0.6, "n": 2})
+        self.assertEqual(s["counts"]["topic"], {"security": 1, "support": 1})
+        self.assertEqual([f["row"] for f in s["flagged"]], [1])
+        self.assertEqual(len(laya_tag.summarize(items, rows, show_all=True)["all"]), 3)
+
+    def test_high_score_alone_flags(self):
+        self.assertTrue(laya_tag.flagged({"severity": 2.0}))
+        self.assertFalse(laya_tag.flagged({"severity": 1.9, "spam": False, "topic": "x"}))
+
+
+class Fallback(unittest.TestCase):
+    def call(self, run=None, side_effect=None, exe="/bin/laya", env="1"):
+        with mock.patch.dict(os.environ, {"LUCKIEST_LAYA": env}), \
+             mock.patch.object(laya_tag, "laya_bin", return_value=exe), \
+             mock.patch.object(laya_tag.subprocess, "run", return_value=run, side_effect=side_effect) as m:
+            try:
+                return laya_tag.laya_answers(["a", "b"], ["--preset", "guard"]), m
+            except laya_tag.Unavailable as e:
+                return e, m
+
+    def test_one_call_passes_mode(self):
+        out, m = self.call(done([{}, {}]))
+        self.assertEqual(len(out), 2)
+        self.assertEqual(m.call_args[0][0][1:3], ["--preset", "guard"])
+
+    def test_unavailable_cases(self):
+        cases = [
+            dict(env="0"),
+            dict(exe=None),
+            dict(side_effect=subprocess.TimeoutExpired("laya", 60)),
+            dict(run=done([], code=1)),
+            dict(run=subprocess.CompletedProcess([], 0, "not json", "")),
+            dict(run=done([{}])),
+        ]
+        for kw in cases:
+            out, _ = self.call(**kw)
+            self.assertIsInstance(out, laya_tag.Unavailable, kw)
+        _, m = self.call(env="0")
+        m.assert_not_called()
+
+    def test_off_by_default(self):
+        with mock.patch.dict(os.environ, {"LUCKIEST_LAYA": ""}), \
+             mock.patch.object(laya_tag, "CONFIG_PATH", "/nonexistent/config.json"):
+            self.assertFalse(laya_tag.laya_preferred())
+
+    def test_main_exit_codes(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
+            f.write("one\n\ntwo\n")
+        err = io.StringIO()
+        with mock.patch.dict(os.environ, {"LUCKIEST_LAYA": "0"}), mock.patch("sys.stderr", err):
+            self.assertEqual(laya_tag.main(["--preset", "guard", f.name]), 2)
+        self.assertIn("by hand", err.getvalue())
+        for bad in ([f.name], ["--preset", "guard", "--questions", "q.json", f.name],
+                    ["--questions", "/nonexistent.json", f.name]):
+            with self.assertRaises(SystemExit):
+                laya_tag.main(bad)
+        os.unlink(f.name)
+
+
+class Input(unittest.TestCase):
+    def test_csv_column(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".csv", delete=False, newline="") as f:
+            f.write('id,text\n1,"multi\nline"\n2,\n3,ok\n')
+        self.assertEqual(laya_tag.read_items(f.name, "text"), ["multi line", "ok"])
+        os.unlink(f.name)
+
+
+if __name__ == "__main__":
+    unittest.main()