luckiest-co 1.0.59 → 1.0.61

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()

package/skills/customer-research/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog — luckiest-customer-research
 
+## 1.3.0 — 2026-11-01
+- Optional Laya tagging: `scripts/triage.py` tags reviews, tickets and survey answers locally (intent, refund, frustration, urgency, churn risk) when the user prefers Laya (`{"laya": true}` or `LUCKIEST_LAYA=1`). Exit 2 means skip it; the skill works as before without Laya.
+
 ## 1.2.0 — 2026-10-08
 Upstream sync with coreyhaines31/marketingskills dda3841 (issue #112).
 

package/skills/customer-research/SKILL.md

@@ -3,7 +3,7 @@ name: customer-research
 description: "When the user wants to conduct, analyze, or synthesize customer research. Use when the user mentions \"customer research,\" \"ICP research,\" \"talk to customers,\" \"analyze transcripts,\" \"customer interviews,\" \"survey analysis,\" \"support ticket analysis,\" \"voice of customer,\" \"VOC,\" \"build personas,\" \"customer personas,\" \"jobs to be done,\" \"JTBD,\" \"what do customers say,\" \"what are customers struggling with,\" \"Reddit mining,\" \"G2 reviews,\" \"review mining,\" \"digital watering holes,\" \"community research,\" \"forum research,\" \"competitor reviews,\" \"customer sentiment,\" or \"find out why customers churn/convert/buy.\" Use for both analyzing existing research assets AND gathering new research from online sources. For writing copy informed by research, see luckiest-copywriting. For acting on research to improve pages, see luckiest-cro."
 license: See ATTRIBUTION.md
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
   listing_id: luckiest-customer-research
   author: luckiest
 ---
@@ -16,9 +16,9 @@ This skill acts as an expert customer researcher. Its goal is to help uncover wh
 
 ## Staying current
 
-On activation, call the Luckiest MCP check_updates tool with { listingId: "8e289fdd-4950-4503-ae10-c1426e861a12", 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.
+On activation, call the Luckiest MCP check_updates tool with { listingId: "8e289fdd-4950-4503-ae10-c1426e861a12", installedSemver: "1.3.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-customer-research", 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.
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-customer-research", skill_version: "1.3.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
 
@@ -66,6 +66,20 @@ Most engagements combine both. Establish which mode applies before proceeding.
 - Passives and detractors are higher signal than promoters for improvement work
 - Pair scores with verbatims — a 9 with a specific complaint beats a 10 with no comment
 
+### Optional: fast tagging with Laya
+
+When there are more than about 30 short messages (reviews, tickets, survey answers, call notes split one per line), try tagging them locally first:
+
+```bash
+python3 scripts/triage.py messages.txt            # one message per line
+python3 scripts/triage.py reviews.csv --column body
+```
+
+- 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 off, missing, or failed. Skip this step and work through the messages by hand as below. Nothing else changes.
+- On success it prints intent counts, the share of messages that are urgent, ask for a refund, or hint at leaving, average frustration (0 to 3), and up to 20 flagged messages. Use the counts for frequency and intensity scoring, and read the flagged messages first for pains and money quotes. Laya tags support intent, not jobs to be done, so still run the extraction framework on what you read.
+- Messages Laya is unsure about are counted as `unsure`. Read a sample of them by hand.
+
 ### Extraction Framework
 
 For each asset, extract:

package/skills/customer-research/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/customer-research/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/launch/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog — luckiest-launch
 
+## 1.3.0 - 2026-11-04
+- New sub-skill: luckiest-usertest walks the funnel with blind personas before friendly testers (Phase 1).
+
 ## 1.2.0 — 2026-10-16
 From coreyhaines31/marketingskills at 1efedbc (issue #174, MIT).
 

package/skills/launch/SKILL.md

@@ -3,7 +3,7 @@ name: launch
 description: "When the user wants to plan a product launch, feature announcement, or release strategy. Also use when the user mentions 'launch,' 'Product Hunt,' 'feature release,' 'announcement,' 'go-to-market,' 'beta launch,' 'early access,' 'waitlist,' 'product update,' 'how do I launch this,' 'site launch,' 'go live,' 'pre-launch QA,' 'launch checklist,' 'GTM plan,' 'we're about to ship,' 'changelog,' 'release notes,' or 'what did we ship this week.' Use this whenever someone is preparing to release something publicly. For ongoing marketing after launch, see luckiest-marketing-ideas. For the offer being launched (bonuses, guarantees, scarcity, naming), see luckiest-offers."
 license: See ATTRIBUTION.md
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
   listing_id: luckiest-launch
   author: luckiest
 ---
@@ -14,9 +14,9 @@ This skill helps the user plan SaaS product launches and feature announcements t
 
 ## Staying current
 
-On activation, call the Luckiest MCP check_updates tool with { listingId: "b65cba33-d644-4eda-b14b-aea9b19f203e", 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.
+On activation, call the Luckiest MCP check_updates tool with { listingId: "b65cba33-d644-4eda-b14b-aea9b19f203e", installedSemver: "1.3.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-launch", 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.
+When the skill's work is done, call the Luckiest MCP report_usage tool once with { listing_id: "luckiest-launch", skill_version: "1.3.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
 
@@ -120,7 +120,7 @@ Gather initial feedback and iron out major issues before going public.
 
 **Actions:**
 - Recruit early users one-on-one to test for free
-- Collect feedback on usability gaps and missing features
+- Collect feedback on usability gaps and missing features (run `luckiest-usertest` first so friendly testers spend their time on what AI testers cannot find)
 - Ensure prototype is functional enough to demo (doesn't need to be production-ready)
 
 **Goal:** Validate core functionality with friendly users.
@@ -379,6 +379,14 @@ After delivering a launch plan, offer (never auto-post): "Want me to share this
 
 ---
 
+## Sub-skills
+
+| Step | Sub-skill | Owns |
+|---|---|---|
+| Phase 1: Internal Launch | `luckiest-usertest` | Buyer-type testers walk the landing page, signup, and welcome before friendly testers see it, with fixes on a preview until the route holds |
+
+If a sub-skill is not installed, say so in one line and do its step with the rules in this skill's references.
+
 ## Related Skills
 
 - **luckiest-marketing-ideas**: For additional launch tactics (Product Hunt, Early Access Referrals)

package/skills/model-router/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — luckiest-model-router
 
+## 2.3.0 — 2026-11-01
+Optional Laya engine for model mode.
+
+- Users who prefer Laya set `{"model_router": "laya"}` in `~/.luckiest/config.json`
+  or `LUCKIEST_MODEL_ROUTER=laya`. One `laya --preset router --batch` call per plan.
+- Rules stay in charge: Laya picks the tier only when the rules are unsure, and
+  otherwise moves it one step when at least 60% sure. Light floor still applies.
+- Batch items take an optional `detail` (the "done means" line) for Laya.
+- Missing, slow (60s + 0.5s per task), failing or unsure Laya leaves the rules' pick and adds a warning.
+
 ## 2.2.0 — 2026-10-16
 Model ids refreshed (issue #198), matching `server/mcp/modelHint.js`.
 

package/skills/model-router/SKILL.md

@@ -3,7 +3,7 @@ name: model-router
 description: Use when the user asks which agent or which model should handle a task. Two modes. Agent mode detects which of Claude, Codex, Cursor, Conductor, or Factory is installed and picks the best fit for the prompt. Model mode tags each task with a Haiku, Sonnet, or Opus tier by task type, so subagents run on the smallest model that fits. Triggers include "which tool should I use", "route this", "best model for this task", "haiku or opus", "which model for each task", "tag tasks with models", and /luckiest plan drafting a task list. Use it whenever someone is choosing between coding agents or model sizes, even if they don't name one.
 license: See ATTRIBUTION.md
 metadata:
-  version: "2.2.0"
+  version: "2.3.0"
   listing_id: luckiest-model-router
   author: luckiest
 ---
@@ -21,9 +21,9 @@ Rules for both modes:
 
 ## Staying current
 
-On activation, call the Luckiest MCP check_updates tool with { listingId: "641e0cd7-0695-4caf-b97a-f7a0b3f872ec", installedSemver: "2.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: "641e0cd7-0695-4caf-b97a-f7a0b3f872ec", installedSemver: "2.3.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-model-router", skill_version: "2.2.0", matched: true, success: <true if the skill completed, false otherwise> }. Send 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-model-router", skill_version: "2.3.0", matched: true, success: <true if the skill completed, false otherwise> }. Send metadata only, never prompt text. Never block on it. If the tool is unavailable, skip silently.
 
 ## Model mode
 
@@ -63,6 +63,15 @@ Use this mode when the question is about model size, or when /luckiest plan is t
 4. Treat the script as a starting point. When the title undersells the task, raise the tier and say why in the reason. Only lower a tier when the task is clearly trivial.
 5. Model IDs: light `claude-haiku-5-5`, standard `claude-sonnet-5-5`, heavy `claude-opus-5-5`. Setting `LUCKIEST_MODEL_PROVIDER=openai` or `google` switches to that provider's table, which matches the server. When showing tiers to the user, say **Haiku**, **Sonnet** or **Opus**. When a subagent runs the task, always pass its model explicitly. Claude Code subagents inherit the session model when none is set, and that is Opus by default.
 
+### Laya engine (optional)
+
+Users who have [Laya](https://huggingface.co/convaiinnovations/laya) installed can prefer it. Turn it on with `{"laya": true}` in `~/.luckiest/config.json` (the shared switch other skills read too) or `{"model_router": "laya"}` for routing only. `LUCKIEST_LAYA=1` and `LUCKIEST_MODEL_ROUTER=laya` do the same from the environment. `LUCKIEST_MODEL_ROUTER=rules` turns Laya off for routing and wins over everything else. The script finds `laya` on PATH or at `~/.venvs/laya/bin/laya` and makes one batch call for the whole plan.
+
+- The rules above still decide. Laya picks the tier only for tasks the rules mark unsure, and otherwise moves the rules' tier by one step when it is at least 60% sure. The light floor for tool-heavy work still applies.
+- Give each batch item an optional `detail` (for example the task's "done means" line). Laya tells tasks apart much better with a sentence than with a bare title.
+- A reason that contains `laya:` means Laya picked or nudged that tier.
+- If Laya is missing, slow (over 60 seconds plus half a second per task), fails, or is unsure, the rules' pick stands and the output has a warning.
+
 ### Escalation during execution
 
 When a subagent's result fails its "done means" check twice on the same task, re-run the task one tier higher from the start and tell the user in one line. Do not hand a half-done run to the bigger model, because switching models mid-task rewrites most of the actions that follow. Tasks that depend on it and have not started yet move up to at least the new tier. Heavy is the ceiling. If a heavy run still fails, stop and hand the task back to the user.