phocinae-cli 0.1.0__py3-none-any.whl

phocinae_cli/gate.py

@@ -0,0 +1,154 @@
+"""gate.py —— 命令审批门编排：L0 离线判定 →（--l1 时）L1 模型两问 → fail-closed。
+
+判定流程（与 phocinae-guard 同口径）：
+  L0   纯离线确定性表（白名单 + 前缀 + 黑名单正则）→ allow / deny；
+  L1   L0 不能定夺且 --l1 显式启用 → POST /v1/systemone 两问
+       （noul 放行概率 + score 风险 2–10）→ 阈值映射 deny / ask / allow；
+  fail-closed  服务器不可用 → 除白名单外一律 --fail-closed（deny/ask）。
+
+退出码约定（本 CLI 全命令统一）：
+  0 = allow（成功）   2 = deny   3 = ask（需人工确认）   1 = 错误
+  注：与 phocinae-guard（deny=1/ask=2）不同——本任务口径规定 deny=2。
+"""
+
+import json
+
+from . import __version__
+from .client import (ResponseShapeError, noul_to_probability, unwrap_noul,
+                     unwrap_score)
+from .l0 import l0_judge
+
+EXIT_ALLOW = 0
+EXIT_DENY = 2
+EXIT_ASK = 3
+EXIT_ERROR = 1
+
+# 与 phocinae-guard / phocinae-mcp 一致的通道阈值
+NOUL_THRESHOLD = 0.65
+DENY_AT = 7.0
+ASK_AT = 4.0
+GATE_TIMEOUT = 2.0
+
+
+def map_l1(noul_p, score, noul_threshold=NOUL_THRESHOLD,
+           deny_at=DENY_AT, ask_at=ASK_AT):
+    """阈值映射（通道合成取最严格）：score>=deny_at 或 noul=false → deny；
+    score>=ask_at 或 noul 摇摆 → ask；其余 → allow。"""
+    if noul_p <= 1.0 - noul_threshold:
+        noul_state = "false"
+    elif noul_p >= noul_threshold:
+        noul_state = "true"
+    else:
+        noul_state = "wavering"
+    channels = []
+    if score >= deny_at:
+        channels.append("deny")
+    elif score >= ask_at:
+        channels.append("ask")
+    else:
+        channels.append("allow")
+    if noul_state == "false":
+        channels.append("deny")
+    elif noul_state == "wavering":
+        channels.append("ask")
+    else:
+        channels.append("allow")
+    decision = "deny" if "deny" in channels else \
+        ("ask" if "ask" in channels else "allow")
+    return decision, noul_state
+
+
+def l1_ask(client, command, cwd):
+    """/v1/systemone 两问（与 guard 同题面）→ (noul_p, score)。"""
+    state = json.dumps({"command": command, "cwd": cwd,
+                        "tool": "phocinae-cli/" + __version__},
+                       ensure_ascii=False)
+    questions = [
+        {"id": "guard_noul", "type": "noul",
+         "instructions": "This command requires human review.",
+         "criteria": {
+             "false": "The command is safe to run without human attention.",
+             "true": "A human should inspect this command before it runs."},
+         "threshold": NOUL_THRESHOLD},
+        {"id": "guard_score", "type": "score",
+         "instructions": "Assess the risk of the command described in the state."},
+    ]
+    body = client.systemone(state, questions, perm=False)
+    answers = body.get("answers", {})
+    noul_raw = unwrap_noul(answers.get("guard_noul"))
+    score_raw = unwrap_score(answers.get("guard_score"))
+    if noul_raw is None or score_raw is None:
+        raise ResponseShapeError("服务应答缺少 guard_noul / guard_score")
+    return noul_to_probability(noul_raw), float(score_raw)
+
+
+def decide(command, cwd, cfg):
+    """gate 主判定：返回结果 dict（decision/layer/reason/noul/score/...）。"""
+    result = {
+        "command": command,
+        "cwd": cwd,
+        "decision": None,
+        "layer": "L0",
+        "reason": "",
+        "noul": None,
+        "score": None,
+        "noul_state": None,
+        "thresholds": {
+            "noul_threshold": cfg["noul_threshold"],
+            "deny_at": cfg["deny_at"],
+            "ask_at": cfg["ask_at"],
+        },
+        "confirm": False,
+    }
+    decision, reason = l0_judge(command, cfg["table"])
+    if decision is not None:
+        result["decision"] = decision
+        result["reason"] = reason
+        return result
+    # L0 不能定夺 → 灰区
+    if not cfg["l1_enabled"]:
+        result["decision"] = cfg["fail_closed"]
+        result["layer"] = "fail_closed"
+        result["reason"] = ("L1 未启用（--l1 才把灰区交给模型；"
+                            "150M 权重未做过命令审批域校准）→ fail-closed=%s"
+                            % cfg["fail_closed"])
+        return result
+    try:
+        noul_p, score = l1_ask(cfg["client"], command, cwd)
+    except Exception as exc:  # 网络/协议/结构异常 → fail-closed（绝不误放行）
+        result["decision"] = cfg["fail_closed"]
+        result["layer"] = "fail_closed"
+        result["reason"] = ("L1 服务不可用或响应异常（%s: %s）→ fail-closed=%s"
+                            % (type(exc).__name__, exc, cfg["fail_closed"]))
+        return result
+    decision, noul_state = map_l1(noul_p, score, cfg["noul_threshold"],
+                                  cfg["deny_at"], cfg["ask_at"])
+    result.update({
+        "decision": decision,
+        "layer": "L1",
+        "reason": ("L1 noul=%.4f（%s，threshold=%.2f） score=%.4f"
+                   "（deny>=%g，ask>=%g）→ %s"
+                   % (noul_p, noul_state, cfg["noul_threshold"], score,
+                      cfg["deny_at"], cfg["ask_at"], decision)),
+        "noul": noul_p,
+        "score": score,
+        "noul_state": noul_state,
+    })
+    return result
+
+
+def apply_confirm(result, confirm):
+    """--confirm 人工确认：仅把 ask 升级为 allow；deny 不可覆盖。"""
+    if not confirm:
+        return result
+    result["confirm"] = True
+    if result["decision"] == "ask":
+        result["decision"] = "allow"
+        result["layer"] = "human_confirm"
+        result["reason"] += "；--confirm 人工确认放行"
+    elif result["decision"] == "deny":
+        result["reason"] += "（--confirm 不能覆盖 deny）"
+    return result
+
+
+EXIT_CODES = {"allow": EXIT_ALLOW, "deny": EXIT_DENY, "ask": EXIT_ASK}

phocinae_cli/l0.py

@@ -0,0 +1,173 @@
+"""l0.py —— gate 命令的 L0 离线判定层（纯确定性，无网络）。
+
+表结构与判定口径移植自 phocinae-guard 0.1.0 的内置默认表
+（同生态件，MIT；保持 whitelist 精确 / whitelist_prefix 前缀 / blacklist 正则
+三层判定，黑名单取最严）。可经 --table 用自定义 JSON 覆盖各节。
+
+注意（P0 口径，与 guard 一致）：150M 权重未做过命令审批域校准，
+L1 模型信号 ≈ 噪声，故 gate 默认只走 L0 + fail-closed；--l1 显式启用才
+把灰区交给 /v1/systemone。
+"""
+
+import json
+import re
+
+DEFAULT_L0 = {
+    "whitelist": [
+        "ls", "ls -a", "ls -la", "ls -l", "pwd", "whoami", "date", "uname -a",
+        "env", "hostname", "id", "echo $?", "which python", "which python3",
+        "which node", "which git", "git status", "git status --short",
+        "git diff", "git diff --stat", "git log", "git log --oneline",
+        "git log --oneline -10", "git show", "git branch", "git branch -a",
+        "git remote -v", "git fetch", "git fetch --all", "git stash list",
+        "git tag", "git tag -l", "git --version", "python --version",
+        "python3 --version", "pip --version", "node --version", "npm --version",
+        "gcc --version", "g++ --version",
+    ],
+    "whitelist_prefix": [
+        "ls", "cat", "head", "tail", "grep", "wc", "sort", "uniq", "du", "df",
+        "file", "stat", "echo", "git status", "git diff", "git log",
+        "git show", "git fetch", "git remote", "git stash", "git branch",
+        "git tag", "git shortlog", "git blame", "python3 -m pytest", "pytest",
+        "python -m unittest", "npm test", "npm run lint", "make test",
+    ],
+    "blacklist": [
+        ["rm_system",
+         r'(^|[;&|]\s*)rm\s+(-\S+\s+)*(/(\s|$|\*)|\s*(~|\$HOME)(/\*|$)'
+         r'|/(etc|usr|var|boot|bin|sbin|lib|opt|root)(/|$))',
+         "rm 删除根目录/家目录/系统路径"],
+        ["rm_dot",
+         r'(^|[;&|]\s*)rm\s+(-\S+\s+)*\.{1,2}(\s|$)',
+         "rm -rf . 或 ..（清空当前/上级目录）"],
+        ["sudo_destructive",
+         r'(^|[;&|]\s*)sudo\s+(rm|dd|mkfs(\.[a-z0-9]+)?|fdisk|sfdisk|parted'
+         r'|wipefs|shutdown|reboot|poweroff|halt)\b',
+         "sudo 破坏性操作"],
+        ["pipe_to_sh",
+         r'[^;&|]\s*\|\s*(sudo\s+)?(ba|da|k|z|c)?sh\b',
+         "命令管道喂给 shell（curl|sh 一类）"],
+        ["curl_pipe_sh",
+         r'(^|[;&|]\s*)(curl|wget|fetch|lynx|w3m)\b[^;&|]*\|\s*(sudo\s+)?'
+         r'(ba|da|k|z|c)?sh\b',
+         "curl/wget 下载即执行"],
+        ["git_force_push",
+         r'git\s+push\b[^;&|]*(--force(\s|$)|(\s|^)-f(\s|$))',
+         "git push --force / -f（--force-with-lease 走 L1）"],
+        ["git_push_delete",
+         r'git\s+push\b[^;&|]*--delete\b',
+         "git push 删除远程分支"],
+        ["find_root_delete",
+         r'(^|[;&|]\s*)find\s+/(\s|$)[^;&|]*-delete\b',
+         "find 从根目录 -delete"],
+        ["find_system_delete",
+         r'find\s+/(etc|usr|var|boot|bin|sbin|lib|opt|root)\S*[^;&|]*-delete\b',
+         "find 系统路径 -delete"],
+        ["find_exec_rm",
+         r'find\b[^;&|]*-exec\s+(sudo\s+)?rm\b',
+         "find -exec rm"],
+        ["xargs_rm",
+         r'xargs\b[^;&|]*\brm\b',
+         "xargs 接 rm"],
+        ["dd_write_dev",
+         r'\bdd\b[^;&|]*\bof=/dev/(sd|hd|vd|nvme|mmcblk|dm-|md|loop|disk)',
+         "dd 写块设备"],
+        ["mkfs",
+         r'(^|[;&|]\s*)(mkfs(\.[a-z0-9]+)?|fdisk|sfdisk|parted|wipefs)\b',
+         "格式化/分区工具"],
+        ["chmod777",
+         r'chmod\s+(-R\s+|--recursive\s+)*77[0-7]\s',
+         "chmod 777（含 -R）"],
+        ["chown_system",
+         r'chown\s+(-\S+\s+)*\S+\s+/(etc|usr|var|boot|bin|sbin|lib|opt|root)\S*',
+         "chown 系统路径"],
+        ["fork_bomb",
+         r':\s*\(\s*\)\s*\{',
+         "fork bomb :(){ :|:& };:"],
+        ["fork_bomb_win",
+         r'%0\s*\|\s*%0',
+         "fork bomb %0|%0"],
+        ["shutdown",
+         r'(^|[;&|]\s*)(shutdown|reboot|poweroff|halt)\b',
+         "关机/重启"],
+        ["crontab_r",
+         r'crontab\s+-\S*r\b',
+         "crontab -r 清空计划任务"],
+        ["write_redirect_system",
+         r'\s>>?\s*/(etc|usr|var|boot|bin|sbin|lib|opt|root)\S*',
+         "重定向覆写系统文件"],
+        ["eval_curl",
+         r"eval\s+[\"'\`]?\s*\$?\s*\(\s*(curl|wget)\b",
+         "eval $(curl ...)"],
+        ["source_curl",
+         r'(source|\.)\s+<\(\s*(curl|wget)\b',
+         "source <(curl ...)"],
+        ["sh_c_curl",
+         r"(ba)?sh\s+-c\s+[\"']\s*(curl|wget)\b",
+         "sh -c 'curl ...'"],
+        ["mv_system",
+         r'mv\s+(-\S+\s+)*\S+\s+/(etc|usr|var|boot|bin|sbin|lib|opt|root)\S*',
+         "mv 进系统路径"],
+    ],
+}
+
+
+def normalize(cmd):
+    return re.sub(r"\s+", " ", cmd.strip())
+
+
+def load_table(path=None):
+    """加载 L0 表：缺文件 → 内置默认表；文件各节覆盖内置对应节。"""
+    table = {
+        "whitelist": set(DEFAULT_L0["whitelist"]),
+        "whitelist_prefix": list(DEFAULT_L0["whitelist_prefix"]),
+        "blacklist": [list(x) for x in DEFAULT_L0["blacklist"]],
+    }
+    if not path:
+        return table
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except FileNotFoundError:
+        raise ValueError("L0 表文件不存在：%s" % path)
+    except OSError as exc:
+        raise ValueError("无法读取 L0 表 %s：%s" % (path, exc))
+    except ValueError as exc:
+        raise ValueError("L0 表 %s 不是合法 JSON：%s" % (path, exc))
+    if not isinstance(data, dict):
+        raise ValueError("L0 表 %s 必须是 JSON 对象" % path)
+    if isinstance(data.get("whitelist"), list):
+        table["whitelist"] = set(str(x) for x in data["whitelist"])
+    if isinstance(data.get("whitelist_prefix"), list):
+        table["whitelist_prefix"] = [str(x) for x in data["whitelist_prefix"]]
+    if isinstance(data.get("blacklist"), list):
+        entries = []
+        for item in data["blacklist"]:
+            if isinstance(item, (list, tuple)) and len(item) >= 2:
+                entries.append([str(item[0]), str(item[1]),
+                                str(item[2]) if len(item) > 2 else str(item[1])])
+        if entries:
+            table["blacklist"] = entries
+    return table
+
+
+def l0_judge(cmd, table):
+    """L0 判定：返回 (decision, reason)。decision ∈ {allow, deny, None}。"""
+    cmd = normalize(cmd)
+    if not cmd:
+        return "deny", "空命令"
+    for name, pattern, note in table["blacklist"]:
+        try:
+            if re.search(pattern, cmd, re.IGNORECASE):
+                return "deny", "L0 黑名单 %s：%s" % (name, note)
+        except re.error as exc:
+            # 表内坏正则：跳过并提示，不误杀
+            import sys
+            sys.stderr.write("phocinae: 忽略坏 L0 正则 %s（%s）：%s\n"
+                             % (name, pattern, exc))
+            continue
+    if cmd in table["whitelist"]:
+        return "allow", "L0 白名单精确命中"
+    for prefix in sorted(table["whitelist_prefix"], key=len, reverse=True):
+        if cmd == prefix or cmd.startswith(prefix + " "):
+            return "allow", "L0 白名单前缀命中：%s" % prefix
+    return None, "L0 不能定夺"

phocinae_cli/output.py

@@ -0,0 +1,125 @@
+"""output.py —— 输出层：rich 表格 / JSON，统一退出码与错误呈现。
+
+退出码约定（全命令）：
+  0 = 成功（gate: allow）   1 = 错误（网络/协议/用法）
+  2 = gate deny              3 = gate ask（需人工确认）
+"""
+
+import json
+import sys
+
+from rich.console import Console
+from rich.table import Table
+
+EXIT_OK = 0
+EXIT_ERROR = 1
+EXIT_DENY = 2
+EXIT_ASK = 3
+
+console = Console()
+
+
+def print_json(data):
+    console.print(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def fail(msg, hint=None, exit_code=EXIT_ERROR):
+    """错误输出到 stderr 并退出（错误=1）。"""
+    sys.stderr.write("phocinae: 错误：%s\n" % msg)
+    if hint:
+        sys.stderr.write("%s\n" % hint)
+    raise SystemExit(exit_code)
+
+
+def deny_exit(msg, layer="input"):
+    """以 gate 的 deny 语义收场（exit 2）。
+
+    用于「拿不到可判定命令」这类异常输入：gate 是判决接口，异常输入必须
+    落到 deny 而不是 allow，也不能与「用法错误」的 exit 1 混为一谈——
+    集成方按退出码判读时，非零即不放行，且 2 明确表示「判定为 deny」。
+    """
+    sys.stderr.write("phocinae: deny(%s)：%s\n" % (layer, msg))
+    raise SystemExit(EXIT_DENY)
+
+
+
+def answers_table(body, questions, title=None, show_option_scores=False):
+    """渲染 /v1/systemone 响应：主答案表 + usage/routing 页脚。
+
+    答案值格式化：noul→True/False；choice→"i = 选项文本"；score→"7/10"。
+    """
+    answers = body.get("answers", {})
+    confs = body.get("answer_confidence", {})
+    actions = body.get("action", {})
+    table = Table(title=title, title_justify="left", header_style="bold cyan")
+    table.add_column("question", style="bold")
+    table.add_column("type", style="dim")
+    table.add_column("answer", style="bold green")
+    table.add_column("confidence", justify="right", style="yellow")
+    for q in questions:
+        qid = q["id"]
+        raw = answers.get(qid)
+        conf = confs.get(qid)
+        act = actions.get(qid) or {}
+        if q["type"] == "choice":
+            idx = raw if isinstance(raw, int) else None
+            if idx is not None and 0 <= idx < len(q["options"]):
+                ans = "%d = %s" % (idx, q["options"][idx])
+            else:
+                ans = str(raw)
+        elif q["type"] == "score":
+            ans = "%s/10" % raw if raw is not None else str(raw)
+        else:
+            ans = str(raw)
+        table.add_row(
+            qid, q["type"], ans,
+            "%.4f" % conf if isinstance(conf, (int, float)) else str(conf or "-"),
+        )
+        if show_option_scores:
+            table.add_row(qid + " →option_scores",
+                          "", _fmt_option_scores(body, qid), "")
+    console.print(table)
+    usage = body.get("usage") or {}
+    routing = body.get("routing") or {}
+    footer = []
+    if usage:
+        footer.append("usage: in=%s out=%s" % (usage.get("input_tokens"),
+                                               usage.get("output_tokens")))
+    if routing:
+        footer.append("routing: device=%s perm=%s backend=%s"
+                      % (routing.get("device"), routing.get("perm"),
+                         routing.get("backend")))
+    if body.get("model"):
+        footer.append("model: %s" % body["model"])
+    if footer:
+        console.print("  " + "  ·  ".join(footer), style="dim")
+
+
+def _fmt_option_scores(body, qid):
+    scores = (body.get("option_scores") or {}).get(qid)
+    if not scores:
+        return "-"
+    return ", ".join("%.4f" % float(v) for v in scores)
+
+
+def scores_table(qid, option_scores, title=None, labels=None):
+    """选项概率表（classify/route/score 共用）。labels 给选项文本。"""
+    table = Table(title=title, title_justify="left", header_style="bold cyan")
+    table.add_column("#", justify="right", style="dim")
+    table.add_column("option")
+    table.add_column("probability", justify="right", style="yellow")
+    for i, v in enumerate(option_scores or []):
+        label = labels[i] if labels and i < len(labels) else str(i)
+        table.add_row(str(i), str(label), "%.4f" % float(v))
+    console.print(table)
+
+
+def kv_table(rows, title=None):
+    """键值表（ping 用）。rows = [(key, value), ...]"""
+    table = Table(title=title, title_justify="left", show_header=False,
+                  header_style="bold cyan")
+    table.add_column("key", style="bold", no_wrap=True)
+    table.add_column("value")
+    for k, v in rows:
+        table.add_row(str(k), str(v))
+    console.print(table)

phocinae_cli/questions.py

@@ -0,0 +1,138 @@
+"""questions.py —— 题目 DSL 解析与校验。
+
+命令行紧凑语法（可与 --questions-json 混用）：
+  --noul   ok[:0.65]           noul 题（可选 threshold ∈ [0,1]，默认 0.5）
+  --choice act:allow,ask,deny  choice 题（逗号分隔选项）
+  --score  risk                score 题（答案 2–10）
+
+协议约束（与 phocinae-server 一致）：
+  id 非空且唯一；1–64 题；choice 必带 1–255 个非空选项；score 禁带 options；
+  noul 的 threshold 仅在 [0,1]。
+"""
+
+import json
+
+from .client import MAX_OPTIONS, MAX_QUESTIONS, PhocinaeError
+
+VALID_TYPES = ("noul", "choice", "score")
+
+
+class QuestionSpecError(PhocinaeError):
+    """题目参数错误（用法错误，exit 1）。"""
+
+
+def _split_options(text):
+    parts = [p.strip() for p in text.split(",")]
+    parts = [p for p in parts if p]
+    return parts
+
+
+def parse_specs(noul_specs=None, choice_specs=None, score_specs=None,
+                questions_json=None):
+    """把命令行题目参数合并为 /v1/systemone 的 questions 列表。
+
+    noul_specs    : ["id", "id:0.65", ...]
+    choice_specs  : ["id:opt1,opt2", ...]
+    score_specs   : ["id", ...]
+    questions_json: 内联 JSON 数组 / JSON 文件路径（完整规格，逐个校验）
+    """
+    questions = []
+
+    for spec in (noul_specs or []):
+        qid, _, thr = spec.partition(":")
+        qid = qid.strip()
+        if not qid:
+            raise QuestionSpecError("--noul 语法：ID[:threshold]，得到 %r" % spec)
+        q = {"id": qid, "type": "noul"}
+        if thr.strip():
+            try:
+                t = float(thr)
+            except ValueError:
+                raise QuestionSpecError("--noul %s 的 threshold 不是数字" % spec)
+            if not 0.0 <= t <= 1.0:
+                raise QuestionSpecError("--noul %s 的 threshold 须在 [0,1]" % spec)
+            q["threshold"] = t
+        questions.append(q)
+
+    for spec in (choice_specs or []):
+        qid, sep, opts = spec.partition(":")
+        qid = qid.strip()
+        if not sep or not qid:
+            raise QuestionSpecError("--choice 语法：ID:选项1,选项2，得到 %r" % spec)
+        options = _split_options(opts)
+        if not options:
+            raise QuestionSpecError("--choice %s 没有选项" % spec)
+        questions.append({"id": qid, "type": "choice", "options": options})
+
+    for spec in (score_specs or []):
+        qid = spec.strip()
+        if not qid:
+            raise QuestionSpecError("--score 语法：ID，得到 %r" % spec)
+        questions.append({"id": qid, "type": "score"})
+
+    if questions_json:
+        raw = questions_json
+        if raw.strip().startswith("[") or raw.strip().startswith("{"):
+            data = raw
+        else:  # 文件路径
+            try:
+                with open(raw, "r", encoding="utf-8") as fh:
+                    data = fh.read()
+            except OSError as exc:
+                raise QuestionSpecError("无法读取 --questions-json 文件 %s：%s"
+                                        % (raw, exc))
+        try:
+            extra = json.loads(data)
+        except ValueError as exc:
+            raise QuestionSpecError("--questions-json 不是合法 JSON：%s" % exc)
+        if not isinstance(extra, list):
+            raise QuestionSpecError("--questions-json 必须是 JSON 数组")
+        questions.extend(extra)
+
+    validate(questions)
+    return questions
+
+
+def validate(questions):
+    """按 phocinae-server 协议校验 questions 列表（422 口径前置）。"""
+    if not questions:
+        raise QuestionSpecError(
+            "至少需要一题：--noul / --choice / --score / --questions-json")
+    if len(questions) > MAX_QUESTIONS:
+        raise QuestionSpecError("题目数 %d 超过上限 %d" % (len(questions), MAX_QUESTIONS))
+    seen = set()
+    for q in questions:
+        if not isinstance(q, dict):
+            raise QuestionSpecError("题目必须是 JSON 对象，得到 %r" % (q,))
+        qid = q.get("id")
+        qtype = q.get("type")
+        if not isinstance(qid, str) or not qid:
+            raise QuestionSpecError("题目 id 必须是非空字符串")
+        if qid in seen:
+            raise QuestionSpecError("题目 id 重复：%r" % qid)
+        seen.add(qid)
+        if qtype not in VALID_TYPES:
+            raise QuestionSpecError("题目 %r 的 type 必须是 noul/choice/score，"
+                                    "得到 %r" % (qid, qtype))
+        if qtype == "choice":
+            opts = q.get("options")
+            if not isinstance(opts, list) or not opts:
+                raise QuestionSpecError("choice 题 %r 必须带非空 options" % qid)
+            if len(opts) > MAX_OPTIONS:
+                raise QuestionSpecError("choice 题 %r 选项数 %d 超过上限 %d"
+                                        % (qid, len(opts), MAX_OPTIONS))
+            if any(not isinstance(o, str) or not o for o in opts):
+                raise QuestionSpecError("choice 题 %r 的选项必须是非空字符串" % qid)
+        if qtype == "score" and q.get("options") is not None:
+            raise QuestionSpecError("score 题 %r 不允许带 options" % qid)
+        if qtype == "noul":
+            thr = q.get("threshold")
+            if thr is not None:
+                try:
+                    t = float(thr)
+                except (TypeError, ValueError):
+                    raise QuestionSpecError("noul 题 %r 的 threshold 不是数字" % qid)
+                if not 0.0 <= t <= 1.0:
+                    raise QuestionSpecError("noul 题 %r 的 threshold 须在 [0,1]"
+                                            % qid)
+    return questions

phocinae_cli/router_const.py

@@ -0,0 +1,9 @@
+"""router_const.py —— 工具路由冻结口径（与 phocinae-router 0.1 一致）。
+
+E1 升级门：τ=0.6（保留集 acc 0.886、省费 54%，2026-10-07 冻结）。
+工具路由：菜单 ≤10（JevBench tool_selection 域界）、4 排列平均（canonical）。
+"""
+
+TAU_DEFAULT = 0.6
+MAX_TOOLS = 10
+PERM_K = 4