luckiest-co 1.0.59 → 1.0.60

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/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.

package/skills/model-router/scripts/route.py

@@ -7,7 +7,8 @@ Usage:
     python3 route.py --list        # just show what's installed
     python3 route.py --model "task title" [--prefer quality|balanced|cheap]
     python3 route.py --model --batch tasks.json   # or JSON on stdin
-        tasks.json: [{"title": ..., "skill": ..., "depends_on": [0]}]
+        tasks.json: [{"title": ..., "skill": ..., "depends_on": [0], "detail": ...}]
+        detail (optional) is only read by the Laya engine.
 
 --model picks a model tier (light/standard/heavy) per task. The rules are
 ported from Weave Router (Apache 2.0): route each task on its own, classify
@@ -25,6 +26,7 @@ import json
 import os
 import re
 import shutil
+import subprocess
 import sys
 
 # How each tool announces itself on the system. First hit wins.
@@ -165,7 +167,87 @@ def _shift(tier, n):
     return TIERS[max(0, min(len(TIERS) - 1, TIERS.index(tier) + n))]
 
 
-def route_task(title, skill=None, prefer="balanced"):
+# ---- Laya engine (opt-in) -------------------------------------------------
+# Users who prefer Laya set {"laya": true} (any skill) or {"model_router": "laya"}
+# in ~/.luckiest/config.json, or LUCKIEST_LAYA=1 / LUCKIEST_MODEL_ROUTER=laya. Laya's router preset scores difficulty 0-3 and
+# says whether the task needs tools or is sensitive; laya_tier maps that to a
+# tier. The rules stay in charge: Laya decides only when they are unsure, and
+# otherwise moves their tier one step when it is confident. On short task text
+# Laya's scores bunch together, so it is an assistant, not the judge.
+# Any Laya failure or low confidence leaves the rules' pick as is.
+LAYA_CONFIDENCE_FLOOR = 0.4
+LAYA_NUDGE_CONFIDENCE = 0.6
+LAYA_TIMEOUT = 60  # cold start alone can pass 30s; plus half a second per task
+CONFIG_PATH = os.path.expanduser("~/.luckiest/config.json")
+
+
+def laya_preferred():
+    # LUCKIEST_MODEL_ROUTER (laya or rules) wins for routing; LUCKIEST_LAYA and
+    # {"laya": true} are the shared "use Laya wherever skills support it" switch.
+    env = os.environ.get("LUCKIEST_MODEL_ROUTER")
+    if env:
+        return env.strip().lower() == "laya"
+    env = os.environ.get("LUCKIEST_LAYA")
+    if env:
+        return env.strip().lower() in ("1", "true", "yes", "on")
+    try:
+        with open(CONFIG_PATH) as f:
+            cfg = json.load(f)
+        return cfg.get("model_router") == "laya" or cfg.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 laya_answers(titles):
+    """One Laya batch call for all titles. Returns a list of answer dicts, or None."""
+    exe = laya_bin()
+    if not exe:
+        return None
+    lines = "\n".join(" ".join(t.split()) or "-" for t in titles) + "\n"
+    try:
+        run = subprocess.run([exe, "--preset", "router", "--json", "--batch", "-"],
+                             input=lines, capture_output=True, text=True, timeout=LAYA_TIMEOUT + len(titles) // 2)
+        if run.returncode != 0:
+            return None
+        rows = [json.loads(l) for l in run.stdout.splitlines() if l.strip()]
+        answers = [r["answers"] for r in rows]
+    except (OSError, subprocess.TimeoutExpired, ValueError, KeyError, TypeError):
+        return None
+    return answers if len(answers) == len(titles) else None
+
+
+def laya_tier(ans):
+    """Map Laya router answers to (tier, reason, confidence), or None when Laya is unsure."""
+    try:
+        d = ans["difficulty"]
+        confidence = float(d["answer_confidence"])
+        if confidence < LAYA_CONFIDENCE_FLOOR:
+            return None
+        score = float(d["score"])
+        tools = ans["needs_tools"]["noul"] >= 0.5
+        sensitive = ans["is_sensitive"]["noul"] >= 0.5
+    except (KeyError, TypeError, ValueError):
+        return None
+    # ponytail: cutoffs tuned on a handful of tasks; Laya's expected score bunches
+    # around 1-2, so "hard" starts at 1.8. Retune against real plans if tiers drift.
+    if score >= 1.8 or (sensitive and score >= 1.5):
+        tier = "heavy"
+    elif score < 1.2 and not tools:
+        tier = "light"
+    else:
+        tier = "standard"
+    reason = f"laya: difficulty {score:.1f}"
+    reason += ", sensitive" if sensitive else ""
+    reason += ", needs tools" if tools else ""
+    return tier, reason, confidence
+
+
+def route_task(title, skill=None, prefer="balanced", laya=None):
     text = f"{title} {skill or ''}"
     task_type, tier, hits = None, None, []
     for name, base, pattern in TASK_TYPES:
@@ -173,27 +255,35 @@ def route_task(title, skill=None, prefer="balanced"):
         if m:
             task_type, tier, hits = name, base, [m.group(0)]
             break
-    if task_type is None:
+    picked = laya_tier(laya) if laya else None
+    if task_type is None and not picked:
         # Weave rule: never fail open to the cheap model. Unsure means standard.
         return {"tier": "standard", "model": MODELS["standard"], "task_type": "unsure",
                 "reason": "unsure: no task-type signal, defaulting to standard", "signals": []}
-    reason = f"{task_type} task"
-    up = re.search(UPSHIFT, text, re.I)
-    if up:
-        tier = _shift(tier, 1)
-        hits.append(up.group(0))
-        reason += f", upshift for '{up.group(0)}'"
-    elif "```" in title or len(title.split()) > 60:
-        # Same rule as the server fallback: pasted code or a long spec is heavier work.
-        tier = _shift(tier, 1)
-        reason += ", upshift for long or code-bearing task"
+    if task_type is None:
+        tier, reason = picked[0], picked[1]  # rules unsure: Laya decides
+    else:
+        reason = f"{task_type} task"
+        up = re.search(UPSHIFT, text, re.I)
+        if up:
+            tier = _shift(tier, 1)
+            hits.append(up.group(0))
+            reason += f", upshift for '{up.group(0)}'"
+        elif "```" in title or len(title.split()) > 60:
+            # Same rule as the server fallback: pasted code or a long spec is heavier work.
+            tier = _shift(tier, 1)
+            reason += ", upshift for long or code-bearing task"
+        if picked and picked[2] >= LAYA_NUDGE_CONFIDENCE and picked[0] != tier:
+            step = 1 if TIERS.index(picked[0]) > TIERS.index(tier) else -1
+            tier = _shift(tier, step)
+            reason += f", {picked[1]}, nudged {'up' if step > 0 else 'down'}"
     if PREFER_SHIFT.get(prefer, 0):
         tier = _shift(tier, PREFER_SHIFT[prefer])
         reason += f", prefer {prefer}"
-        if tier == "light" and task_type not in LIGHT_FLOOR_EXEMPT:
-            tier = "standard"
-            reason += ", held at standard (tool-heavy work loops on small models)"
-    return {"tier": tier, "model": MODELS[tier], "task_type": task_type,
+    if tier == "light" and task_type not in LIGHT_FLOOR_EXEMPT:
+        tier = "standard"
+        reason += ", held at standard (tool-heavy work loops on small models)"
+    return {"tier": tier, "model": MODELS[tier], "task_type": task_type or "unsure",
             "reason": reason, "signals": hits}
 
 
@@ -203,9 +293,15 @@ def route_batch(tasks, prefer="balanced"):
     A task that depends on another inherits the higher of the two tiers, so a
     chain shares one model and its context, unless a later task needs more.
     """
-    out = [dict(route_task(t.get("title", ""), t.get("skill"), prefer), title=t.get("title", ""))
-           for t in tasks]
     warnings = []
+    # Laya separates tasks far better with a sentence of detail than a bare title.
+    texts = [f"{t.get('title', '')} {t.get('detail') or ''}" for t in tasks]
+    answers = laya_answers(texts) if laya_preferred() else None
+    if laya_preferred() and answers is None:
+        warnings.append("laya preferred but unavailable, used built-in rules")
+    answers = answers or [None] * len(tasks)
+    out = [dict(route_task(t.get("title", ""), t.get("skill"), prefer, a), title=t.get("title", ""))
+           for t, a in zip(tasks, answers)]
     for i, t in enumerate(tasks):
         for dep in t.get("depends_on") or []:
             if not (isinstance(dep, int) and 0 <= dep < i):
@@ -267,7 +363,11 @@ def model_main(args):
     title = " ".join(args).strip() or (sys.stdin.read().strip() if not sys.stdin.isatty() else "")
     if not title:
         sys.exit("give a task title")
-    print(json.dumps(dict(route_task(title, None, prefer), prefer=prefer), indent=2))
+    routed, warnings = route_batch([{"title": title}], prefer)
+    result = dict(routed[0], prefer=prefer)
+    if warnings:
+        result["warnings"] = warnings
+    print(json.dumps(result, indent=2))
 
 
 if __name__ == "__main__":

package/skills/model-router/scripts/test_route.py

@@ -1,8 +1,13 @@
 """Run: python3 -m unittest scripts/test_route.py (from the skill directory)."""
 import os
 import sys
+import json
+import subprocess
+import tempfile
 import unittest
+from unittest import mock
 
+os.environ["LUCKIEST_MODEL_ROUTER"] = "rules"  # keep the user's own preference out of tests
 sys.path.insert(0, os.path.dirname(__file__))
 import route  # noqa: E402
 
@@ -49,5 +54,88 @@ class RouteTask(unittest.TestCase):
                          {"light": "claude-haiku-5-5", "standard": "claude-sonnet-5-5", "heavy": "claude-opus-5-5"})
 
 
+def laya_ans(score, conf=0.9, tools=0.1, sensitive=0.1):
+    return {"difficulty": {"score": score, "answer_confidence": conf},
+            "needs_tools": {"noul": tools}, "is_sensitive": {"noul": sensitive}}
+
+
+class Laya(unittest.TestCase):
+    def test_mapping(self):
+        self.assertEqual(route.laya_tier(laya_ans(2.8))[0], "heavy")
+        self.assertEqual(route.laya_tier(laya_ans(1.6, sensitive=0.9))[0], "heavy")
+        self.assertEqual(route.laya_tier(laya_ans(1.6))[0], "standard")
+        self.assertEqual(route.laya_tier(laya_ans(0.6, tools=0.9))[0], "standard")
+        self.assertEqual(route.laya_tier(laya_ans(0.6))[0], "light")
+        self.assertIsNone(route.laya_tier(laya_ans(2.8, conf=0.2)))  # unsure: rules decide
+
+    def test_laya_decides_only_when_rules_unsure(self):
+        r = route.route_task("polish the thing", laya=laya_ans(2.8))
+        self.assertEqual(r["tier"], "heavy")
+        self.assertTrue(r["reason"].startswith("laya:"))
+
+    def test_laya_nudges_one_step_when_confident(self):
+        r = route.route_task("rename the settings label", laya=laya_ans(2.8))
+        self.assertEqual(r["tier"], "standard")  # light -> standard, never two steps
+        self.assertIn("laya:", r["reason"])
+        r = route.route_task("draft the launch email", laya=laya_ans(0.4))
+        self.assertEqual(r["tier"], "light")
+        # under the nudge confidence, the rules' pick stands
+        r = route.route_task("draft the launch email", laya=laya_ans(2.8, conf=0.5))
+        self.assertEqual((r["tier"], r["reason"]), ("standard", "content task"))
+
+    def test_laya_keeps_floor(self):
+        # implement work never drops to light, even when Laya calls it easy
+        self.assertEqual(route.route_task("add a pricing FAQ", laya=laya_ans(0.3))["tier"], "standard")
+        # low confidence falls back to the rules
+        r = route.route_task("design the billing schema", laya=laya_ans(0.3, conf=0.1))
+        self.assertEqual(r["reason"], "design task")
+
+    def run_batch(self, run=None, side_effect=None, exe="/bin/laya"):
+        with mock.patch.dict(os.environ, {"LUCKIEST_MODEL_ROUTER": "laya"}), \
+             mock.patch.object(route, "laya_bin", return_value=exe), \
+             mock.patch.object(route.subprocess, "run", return_value=run, side_effect=side_effect) as m:
+            out, warnings = route.route_batch([{"title": "draft the email"}, {"title": "add the route"}])
+        return out, warnings, m
+
+    def test_batch_one_laya_call(self):
+        stdout = "\n".join(json.dumps({"answers": a}) for a in (laya_ans(0.4), laya_ans(2.9)))
+        out, warnings, m = self.run_batch(subprocess.CompletedProcess([], 0, stdout, ""))
+        self.assertEqual(m.call_count, 1)
+        self.assertEqual([t["tier"] for t in out], ["light", "heavy"])
+        self.assertEqual(warnings, [])
+
+    def test_batch_fallbacks(self):
+        cases = [
+            dict(exe=None),  # not installed
+            dict(side_effect=subprocess.TimeoutExpired("laya", 30)),
+            dict(run=subprocess.CompletedProcess([], 1, "", "boom")),
+            dict(run=subprocess.CompletedProcess([], 0, "not json", "")),
+        ]
+        for kw in cases:
+            out, warnings, _ = self.run_batch(**kw)
+            self.assertEqual([t["reason"] for t in out], ["content task", "implement task"], kw)
+            self.assertEqual(len(warnings), 1, kw)
+
+    def test_shared_switch(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as f:
+            f.write('{"laya": true}')
+        with mock.patch.object(route, "CONFIG_PATH", f.name):
+            with mock.patch.dict(os.environ, {"LUCKIEST_MODEL_ROUTER": "", "LUCKIEST_LAYA": ""}):
+                self.assertTrue(route.laya_preferred())  # shared config key
+            with mock.patch.dict(os.environ, {"LUCKIEST_MODEL_ROUTER": "rules"}):
+                self.assertFalse(route.laya_preferred())  # routing-only off switch wins
+        os.unlink(f.name)
+        with mock.patch.dict(os.environ, {"LUCKIEST_MODEL_ROUTER": "", "LUCKIEST_LAYA": "1"}):
+            self.assertTrue(route.laya_preferred())
+
+    def test_off_by_default(self):
+        with mock.patch.dict(os.environ, {"LUCKIEST_MODEL_ROUTER": "", "LUCKIEST_LAYA": ""}), \
+             mock.patch.object(route, "CONFIG_PATH", "/nonexistent/config.json"), \
+             mock.patch.object(route.subprocess, "run") as m:
+            self.assertFalse(route.laya_preferred())
+            route.route_batch([{"title": "add the route"}])
+        m.assert_not_called()
+
+
 if __name__ == "__main__":
     unittest.main()