cortico-world-simple-trpg-check 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+<!-- Owner: src/definition.ts, src/world.ts, src/config.ts -->
+
+# cortico-world-simple-trpg-check
+
+`simple_trpg_check_roll` 接收 `scenario` 和 `skill_lists`。`scenario` 写明角色使用技能的方法、目标和相关情境，可写熟练程度或身体条件。模型一次评估所有技能的成功把握；World 将每项 `0–1` 数值乘 100、向下取整，限制在 1–99，回执中称为“难度”。每项技能各掷一次 1–100，按输入顺序返回固定判定文本。
+
+1 是大成功，100 是大失败。其余骰值不超过难度的四分之一为极难成功，不超过二分之一为困难成功，不超过难度为普通成功；否则为普通失败。模型不可用或任何一项答案无效时，整次调用返回失败回执，不掷骰。
+
+## 判定模型
+
+`worlds.simple-trpg-check.backend` 可选 `laya-multilingual`（默认）、`laya` 和 `jev`。
+
+- `laya-multilingual`：在“多语言 Laya Python 环境”下拉选单中选择已安装 `laya` 的 Conda 环境，使用 `convaiinnovations/laya` 的 `multilingual` 检查点。选项来自本机 `~/.conda/environments.txt`，缺失或不可读时只显示当前配置值。首次运行可能由 Laya 下载权重；后续使用本地缓存。
+- `laya`：通过可选依赖 `@receptron/laya` 在本机运行英文检查点。
+- `jev`：按 `worlds.simple-trpg-check.jevSource` 选择 TypeSafe 或 OpenRouter 的 System One API。工具调用会将 `scenario` 和技能名称发送给所选服务。配置页的“Jev 来源”下方显示“打开密钥文件”按钮；点击后打开部署目录的 `.env`，缺少当前来源密钥时补入空的 `CORTICO_JEV_TYPESAFE_API_KEY=` 或 `CORTICO_JEV_OPENROUTER_API_KEY=` 行。填写并保存文件后，下一次模型请求读取密钥。旧的 World 专用变量名仍可读取。
+
+World 左栏的状态灯在首次成功完成模型评估后变绿；配置改变或评估失败后更新状态。
+“判定模型”下方的“测试连接”会发送一项英文技能评分请求，不掷骰；结果显示在按钮旁，并更新左栏状态灯。
+
+同一 Cortico 进程中，若 continuity 与此 World 使用相同的 Laya 类型（multilingual 还需同一 Python 路径），两者共用已加载的模型或 worker。请求依次执行；模型在所有使用者空闲后按其中最长的 TTL 回收。`layaIdleTtlMinutes` 默认 10；设为 `0` 且无其他使用者需要保留模型时，每次评分后释放。不同进程不共用运行实例。
+
+“强制适配多语言”勾选后，World 提示 agent 用英文填写 `scenario` 和 `skill_lists`；它不翻译输入，也不切换判定模型。
+
+环境提示词让 agent 只在结果不确定且具有戏剧性的情境中酌情投骰，并在面向用户的文本中写出每项骰值、难度和结果。
+
+## 开发与安装
+
+```sh
+corepack pnpm install
+corepack pnpm typecheck
+corepack pnpm typecheck:web
+corepack pnpm test
+corepack pnpm build:console
+```
+
+包内的 `pnpm-workspace.yaml` 已允许 `esbuild` 与 `onnxruntime-node` 的安装脚本。multilingual 模式需要在下拉选单中选择已安装 `laya` 的 Python 环境。
+
+在 Cortico 仓库根目录运行 `corepack pnpm check:extension <本包绝对路径>`。然后在目标实例的“扩展”页手动安装此目录，并在 World 配置中启用。安装到运行中的实例需要重启进程；本包的测试和装载检查不会启动 bot。

package/dist/console.js

@@ -0,0 +1,70 @@
+// src/console/client.ts
+async function mountCredentials(ctx) {
+  let state = await ctx.invoke("state");
+  render(state);
+  ctx.interval(() => {
+    void ctx.invoke("state").then((next) => {
+      if (next.backend !== state.backend || next.source !== state.source || next.keySet !== state.keySet) {
+        state = next;
+        render(next);
+      }
+    }).catch(() => void 0);
+  }, 2e3);
+  function render(current) {
+    const { ui } = ctx;
+    if (current.backend !== "jev") {
+      ctx.root.replaceChildren();
+      return;
+    }
+    const sourceName = current.source === "openrouter" ? "OpenRouter" : "TypeSafe";
+    const message = ui.msgline(current.keySet ? "\u5BC6\u94A5\u5DF2\u914D\u7F6E" : "\u5BC6\u94A5\u672A\u914D\u7F6E");
+    const open = ui.button(`\u6253\u5F00 ${sourceName} \u5BC6\u94A5\u6587\u4EF6`, {
+      onClick: () => {
+        open.disabled = true;
+        void ctx.invoke("openKeyFile", [current.source]).then(({ file }) => {
+          message.textContent = `\u5DF2\u6253\u5F00 ${file}`;
+          message.classList.remove("bad");
+        }).catch((error) => {
+          message.textContent = `\u6253\u5F00\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`;
+          message.classList.add("bad");
+        }).finally(() => {
+          open.disabled = false;
+        });
+      }
+    });
+    const actions = ui.actions();
+    actions.append(message, open);
+    ctx.root.replaceChildren(actions);
+  }
+}
+function mountConnectionTest(ctx) {
+  const { ui } = ctx;
+  const message = ui.msgline();
+  const button = ui.button("\u6D4B\u8BD5\u8FDE\u63A5", {
+    onClick: () => {
+      button.disabled = true;
+      message.textContent = "\u6D4B\u8BD5\u4E2D\u2026";
+      message.classList.remove("bad");
+      void ctx.invoke("testConnection").then((result) => {
+        message.textContent = result.ok ? "\u8FDE\u63A5\u6210\u529F" : `\u8FDE\u63A5\u5931\u8D25\uFF1A${result.error || "\u6A21\u578B\u6CA1\u6709\u8FD4\u56DE\u6709\u6548\u7ED3\u679C"}`;
+        message.classList.toggle("bad", !result.ok);
+        void ctx.refresh().catch(() => void 0);
+      }).catch((error) => {
+        message.textContent = `\u8FDE\u63A5\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`;
+        message.classList.add("bad");
+      }).finally(() => {
+        button.disabled = false;
+      });
+    }
+  });
+  const actions = ui.actions();
+  actions.append(message, button);
+  ctx.root.replaceChildren(actions);
+}
+var client = {
+  panels: { credentials: { mount: mountCredentials }, "connection-test": { mount: mountConnectionTest } }
+};
+var client_default = client;
+export {
+  client_default as default
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "cortico-world-simple-trpg-check",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "TRPG skill checks with Laya or Jev probability scores and d100 rolls",
+  "license": "MIT",
+  "keywords": [
+    "cortico-world",
+    "cortico"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@11.5.0",
+  "main": "./src/index.ts",
+  "cortico": {
+    "kind": "world",
+    "api": 5,
+    "consoleClient": "dist/console.js"
+  },
+  "files": [
+    "src",
+    "python",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "typecheck:web": "tsc -p tsconfig.web.json --noEmit",
+    "build:console": "esbuild src/console/client.ts --bundle --format=esm --outfile=dist/console.js"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "cortico": "^0.1.3",
+    "esbuild": "^0.28.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "optionalDependencies": {
+    "@receptron/laya": "0.1.2"
+  }
+}

package/python/laya_multilingual_worker.py

@@ -0,0 +1,25 @@
+import contextlib
+import json
+import sys
+
+
+def send(message):
+    sys.__stdout__.write(json.dumps(message, ensure_ascii=False, separators=(',', ':')) + '\n')
+    sys.__stdout__.flush()
+
+
+with contextlib.redirect_stdout(sys.stderr):
+    import laya
+    agent = laya.load('convaiinnovations/laya', subfolder='multilingual')
+
+send({'type': 'ready'})
+for line in sys.stdin:
+    request = {}
+    try:
+        request = json.loads(line)
+        if request.get('type') == 'close':
+            break
+        result = agent.predict(request['state'], request['questions'])
+        send({'id': request['id'], 'ok': True, 'result': result})
+    except Exception as error:
+        send({'id': request.get('id'), 'ok': False, 'error': f'{type(error).__name__}: {error}'})

package/src/ENV_PROMPT.md

@@ -0,0 +1,11 @@
+仅在结果不确定且情境具有戏剧性时酌情进行技能判定：平静地走过明亮门廊无需判定；被怪物追赶时穿过遍布瓦砾的狭窄走廊则适合判定。需要判定时调用 simple_trpg_check_roll。
+
+调用时自行填写 scenario 和 skill_lists。scenario 要写明角色的目标、如何使用列表中的每项技能，以及影响达成目标的条件，例如环境、熟练程度或身体状况。skill_lists 按判定顺序填写技能名称。
+
+simple_trpg_check_roll 收到的 state 是 { scenario: "…" }，并对 skill_lists 中的每项技能分别提出以下问题，其中 <技能名> 替换为该项名称：
+Can the character achieve the stated goal by using the skill "<技能名>" in this scenario? Consider the described method, goal, familiarity, and relevant circumstances.
+填写参数时，确保 scenario 与 skill_lists 自洽，且 scenario 包含回答这些问题所需的条件。
+
+{{simpleTrpgCheck.languageRule}}
+
+根据工具回执继续叙事。面向用户时，按输入顺序用中文技能名列出每项结果，格式为【<技能名>检定：<判定>/<难度> <结果>】；普通成功写“成功”，普通失败写“失败”，其他等级写回执中的结果。例如：【侦查检定：80/40 失败】【灵感检定：20/80 成功】。模型请求失败时依据失败回执处理，不编造骰值。

package/src/check.ts

@@ -0,0 +1,34 @@
+export type CheckResult = '大成功' | '极难成功' | '困难成功' | '普通成功' | '普通失败' | '大失败';
+
+export interface SkillCheck {
+  skill: string;
+  difficulty: number;
+  roll: number;
+  result: CheckResult;
+}
+
+export function difficultyFromProbability(probability: number): number {
+  if (!Number.isFinite(probability) || probability < 0 || probability > 1) {
+    throw new Error('模型返回的成功把握必须是 0–1 的有限数值');
+  }
+  return Math.max(1, Math.min(99, Math.floor(probability * 100)));
+}
+
+export function classify(roll: number, difficulty: number): CheckResult {
+  if (!Number.isInteger(roll) || roll < 1 || roll > 100) throw new Error('骰值必须是 1–100 的整数');
+  if (roll === 1) return '大成功';
+  if (roll === 100) return '大失败';
+  if (roll <= difficulty * 0.25) return '极难成功';
+  if (roll <= difficulty * 0.5) return '困难成功';
+  return roll <= difficulty ? '普通成功' : '普通失败';
+}
+
+export function formatChecks(checks: SkillCheck[]): string {
+  return checks.map(({ skill, difficulty, roll, result }) => {
+    const advice = result === '大成功' ? '给予额外奖励。'
+      : result === '大失败' ? '给予额外惩罚。'
+        : result === '极难成功' || result === '困难成功' ? '酌情给予小奖励。'
+          : '';
+    return `${skill}：${result} [${roll}/${difficulty}]\n此次${skill}${result}了。${advice}`;
+  }).join('\n\n');
+}

package/src/conda-environments.ts

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { basename, join } from 'node:path';
+
+export interface CondaPythonOption {
+  value: string;
+  label: string;
+}
+
+export function listCondaPythonOptions(
+  manifest: string,
+  exists: (path: string) => boolean = existsSync,
+  targetPlatform: NodeJS.Platform = platform(),
+): CondaPythonOption[] {
+  const executable = targetPlatform === 'win32' ? 'python.exe' : join('bin', 'python');
+  const seen = new Set<string>();
+  const options: CondaPythonOption[] = [];
+  for (const line of manifest.split(/\r?\n/u)) {
+    const prefix = line.trim();
+    if (!prefix || seen.has(prefix)) continue;
+    seen.add(prefix);
+    const pythonExecutable = join(prefix, executable);
+    if (!exists(pythonExecutable)) continue;
+    options.push({ value: pythonExecutable, label: `${basename(prefix)} · ${prefix}` });
+  }
+  return options;
+}
+
+export function discoverCondaPythonOptions(): CondaPythonOption[] {
+  try {
+    return listCondaPythonOptions(readFileSync(join(homedir(), '.conda', 'environments.txt'), 'utf8'));
+  } catch {
+    return [];
+  }
+}

package/src/config.ts

@@ -0,0 +1,74 @@
+import type { ConfigGroup } from 'cortico/core/types.ts';
+
+export type CheckBackend = 'laya' | 'laya-multilingual' | 'jev';
+export type JevSource = 'typesafe' | 'openrouter';
+
+export interface SimpleTrpgCheckConfigSection {
+  enabled: boolean;
+  backend: CheckBackend;
+  jevSource: JevSource;
+  forceMultilingual: boolean;
+  pythonExecutable: string;
+  layaIdleTtlMinutes: number;
+}
+
+export const SIMPLE_TRPG_CHECK_DEFAULTS: SimpleTrpgCheckConfigSection = {
+  enabled: false,
+  backend: 'laya-multilingual',
+  jevSource: 'typesafe',
+  forceMultilingual: false,
+  pythonExecutable: 'python',
+  layaIdleTtlMinutes: 10,
+};
+
+export const SIMPLE_TRPG_CHECK_TYPESAFE_SECRET = 'CORTICO_JEV_TYPESAFE_API_KEY';
+export const SIMPLE_TRPG_CHECK_OPENROUTER_SECRET = 'CORTICO_JEV_OPENROUTER_API_KEY';
+export const SIMPLE_TRPG_CHECK_LEGACY_TYPESAFE_SECRET = 'CORTICO_SIMPLE_TRPG_CHECK_TYPESAFE_API_KEY';
+export const SIMPLE_TRPG_CHECK_LEGACY_OPENROUTER_SECRET = 'CORTICO_SIMPLE_TRPG_CHECK_OPENROUTER_API_KEY';
+
+export const SIMPLE_TRPG_CHECK_CONFIG_GROUP: ConfigGroup = {
+  id: 'world:simple-trpg-check',
+  owner: 'world:simple-trpg-check',
+  schema: {
+    type: 'object',
+    title: 'Simple TRPG Check',
+    properties: {
+      'worlds.simple-trpg-check.backend': {
+        type: 'string',
+        title: '判定模型',
+        enum: ['laya-multilingual', 'laya', 'jev'],
+        'x-hot': false,
+        'x-panel-slot': 'model-test',
+      },
+      'worlds.simple-trpg-check.jevSource': {
+        type: 'string',
+        title: 'Jev 来源',
+        enum: ['typesafe', 'openrouter'],
+        'x-hot': true,
+        'x-panel-slot': 'jev-key',
+      },
+      'worlds.simple-trpg-check.forceMultilingual': {
+        type: 'boolean',
+        title: '强制适配多语言',
+        description: '要求 agent 用英文填写 scenario 与 skill_lists；不翻译输入，也不切换模型。',
+        'x-hot': true,
+      },
+      'worlds.simple-trpg-check.pythonExecutable': {
+        type: 'string',
+        title: '多语言 Laya Python 环境',
+        'x-options': 'simple-trpg-check-conda-python',
+        description: '从本机 Conda 环境中选择；该环境需安装 laya。',
+        'x-hot': false,
+      },
+      'worlds.simple-trpg-check.layaIdleTtlMinutes': {
+        type: 'integer',
+        title: 'Laya 空闲释放时间',
+        minimum: 0,
+        multipleOf: 1,
+        'x-suffix': 'min',
+        'x-hot': true,
+        description: '最后一次本地评分后保留模型的分钟数；与其他使用者共用时取最长 TTL。',
+      },
+    },
+  },
+} as ConfigGroup;

package/src/console/client.ts

@@ -0,0 +1,74 @@
+import type { ConsoleClientBundle, ConsolePanelContext } from 'cortico/web/shared/client-panel.ts';
+
+interface KeyState {
+  backend: string;
+  source: 'typesafe' | 'openrouter';
+  keySet: boolean;
+}
+
+async function mountCredentials(ctx: ConsolePanelContext): Promise<void> {
+  let state = await ctx.invoke<KeyState>('state');
+  render(state);
+  ctx.interval(() => {
+    void ctx.invoke<KeyState>('state').then((next) => {
+      if (next.backend !== state.backend || next.source !== state.source || next.keySet !== state.keySet) {
+        state = next;
+        render(next);
+      }
+    }).catch(() => undefined);
+  }, 2_000);
+
+  function render(current: KeyState): void {
+    const { ui } = ctx;
+    if (current.backend !== 'jev') {
+      ctx.root.replaceChildren();
+      return;
+    }
+    const sourceName = current.source === 'openrouter' ? 'OpenRouter' : 'TypeSafe';
+    const message = ui.msgline(current.keySet ? '密钥已配置' : '密钥未配置');
+    const open = ui.button(`打开 ${sourceName} 密钥文件`, {
+      onClick: () => {
+        open.disabled = true;
+        void ctx.invoke<{ file: string }>('openKeyFile', [current.source]).then(({ file }) => {
+          message.textContent = `已打开 ${file}`;
+          message.classList.remove('bad');
+        }).catch((error) => {
+          message.textContent = `打开失败：${error instanceof Error ? error.message : String(error)}`;
+          message.classList.add('bad');
+        }).finally(() => { open.disabled = false; });
+      },
+    });
+    const actions = ui.actions();
+    actions.append(message, open);
+    ctx.root.replaceChildren(actions);
+  }
+}
+
+function mountConnectionTest(ctx: ConsolePanelContext): void {
+  const { ui } = ctx;
+  const message = ui.msgline();
+  const button = ui.button('测试连接', {
+    onClick: () => {
+      button.disabled = true;
+      message.textContent = '测试中…';
+      message.classList.remove('bad');
+      void ctx.invoke<{ ok: boolean; error?: string }>('testConnection').then((result) => {
+        message.textContent = result.ok ? '连接成功' : `连接失败：${result.error || '模型没有返回有效结果'}`;
+        message.classList.toggle('bad', !result.ok);
+        void ctx.refresh().catch(() => undefined);
+      }).catch((error) => {
+        message.textContent = `连接失败：${error instanceof Error ? error.message : String(error)}`;
+        message.classList.add('bad');
+      }).finally(() => { button.disabled = false; });
+    },
+  });
+  const actions = ui.actions();
+  actions.append(message, button);
+  ctx.root.replaceChildren(actions);
+}
+
+const client: ConsoleClientBundle = {
+  panels: { credentials: { mount: mountCredentials }, 'connection-test': { mount: mountConnectionTest } },
+};
+
+export default client;

package/src/definition.ts

@@ -0,0 +1,12 @@
+import type { WorldDefinition } from 'cortico/world.ts';
+import { discoverCondaPythonOptions } from './conda-environments.ts';
+import { SIMPLE_TRPG_CHECK_DEFAULTS, type SimpleTrpgCheckConfigSection } from './config.ts';
+import { SimpleTrpgCheckWorld } from './world.ts';
+
+export const SIMPLE_TRPG_CHECK: WorldDefinition<SimpleTrpgCheckConfigSection> = {
+  id: 'simple-trpg-check',
+  label: 'Simple TRPG Check',
+  defaults: () => ({ ...SIMPLE_TRPG_CHECK_DEFAULTS }),
+  configOptions: (kind) => kind === 'simple-trpg-check-conda-python' ? discoverCondaPythonOptions() : [],
+  create: (ctx) => new SimpleTrpgCheckWorld(ctx),
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+import { SIMPLE_TRPG_CHECK } from './definition.ts';
+
+export default SIMPLE_TRPG_CHECK;
+export { SIMPLE_TRPG_CHECK };
+export type { SimpleTrpgCheckConfigSection } from './config.ts';

package/src/model.ts

@@ -0,0 +1,106 @@
+import type { WorldContext } from 'cortico/world.ts';
+import {
+  SIMPLE_TRPG_CHECK_OPENROUTER_SECRET,
+  SIMPLE_TRPG_CHECK_TYPESAFE_SECRET,
+  SIMPLE_TRPG_CHECK_LEGACY_OPENROUTER_SECRET,
+  SIMPLE_TRPG_CHECK_LEGACY_TYPESAFE_SECRET,
+  type SimpleTrpgCheckConfigSection,
+} from './config.ts';
+import { startMultilingualLaya } from './multilingual-laya.ts';
+import { layaRuntimeKey, sharedLayaPool, type SharedLayaClient, type SharedLayaModel } from './shared-laya.ts';
+
+type Questions = Record<string, { type: 'noul'; instructions: string }>;
+export interface SkillScorer {
+  score(scenario: string, skills: string[]): Promise<number[]>;
+  close(): Promise<void>;
+}
+
+function questionsFor(skills: string[]): Questions {
+  return Object.fromEntries(skills.map((skill, index) => [
+    `skill_${index}`,
+    {
+      type: 'noul',
+      instructions: `Can the character achieve the stated goal by using the skill "${skill}" in this scenario? Consider the described method, goal, familiarity, and relevant circumstances.`,
+    },
+  ]));
+}
+
+function probabilitiesFrom(result: unknown, count: number): number[] {
+  if (!result || typeof result !== 'object') throw new Error('模型没有返回判定结果');
+  const answers = (result as { answers?: unknown }).answers;
+  if (!answers || typeof answers !== 'object' || Array.isArray(answers)) throw new Error('模型没有返回技能答案');
+  const keyed = answers as Record<string, unknown>;
+  if (Object.keys(keyed).length !== count) throw new Error('模型返回的技能答案数量不匹配');
+  return Array.from({ length: count }, (_, index) => {
+    const item = keyed[`skill_${index}`];
+    const value = item && typeof item === 'object' ? (item as { noul?: unknown }).noul : undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {
+      throw new Error(`第 ${index + 1} 项技能的模型答案无效`);
+    }
+    return value;
+  });
+}
+
+export class SystemOneSkillScorer implements SkillScorer {
+  private layaClient: SharedLayaClient | null = null;
+  private layaKey = '';
+
+  constructor(private readonly ctx: WorldContext<SimpleTrpgCheckConfigSection>) {}
+
+  async score(scenario: string, skills: string[]): Promise<number[]> {
+    const questions = questionsFor(skills);
+    const state = { scenario };
+    if (this.ctx.cfg.backend === 'jev') {
+      return probabilitiesFrom(await this.requestJev(state, questions), skills.length);
+    }
+    const result = await this.getLayaClient().systemOne(state, questions);
+    return probabilitiesFrom(result, skills.length);
+  }
+
+  async close(): Promise<void> {
+    const client = this.layaClient;
+    this.layaClient = null;
+    this.layaKey = '';
+    await client?.dispose();
+  }
+
+  private getLayaClient(): SharedLayaClient {
+    const backend = this.ctx.cfg.backend;
+    const variant = backend === 'laya-multilingual' ? 'multilingual' : 'english';
+    const pythonExecutable = this.ctx.cfg.pythonExecutable;
+    const key = layaRuntimeKey(variant, pythonExecutable);
+    if (this.layaClient && this.layaKey === key) return this.layaClient;
+    void this.layaClient?.dispose();
+    this.layaKey = key;
+    this.layaClient = sharedLayaPool().create(
+      key,
+      () => variant === 'multilingual'
+        ? startMultilingualLaya(pythonExecutable)
+        : import('@receptron/laya').then(({ Laya }) => Laya.load() as Promise<SharedLayaModel>),
+      () => this.ctx.cfg.layaIdleTtlMinutes,
+    );
+    return this.layaClient;
+  }
+
+  private async requestJev(state: unknown, questions: Questions): Promise<unknown> {
+    const source = this.ctx.cfg.jevSource;
+    const secretName = source === 'openrouter'
+      ? SIMPLE_TRPG_CHECK_OPENROUTER_SECRET
+      : SIMPLE_TRPG_CHECK_TYPESAFE_SECRET;
+    const apiKey = this.ctx.secret(secretName) || this.ctx.secret(source === 'openrouter'
+      ? SIMPLE_TRPG_CHECK_LEGACY_OPENROUTER_SECRET : SIMPLE_TRPG_CHECK_LEGACY_TYPESAFE_SECRET)
+      || (source === 'typesafe' ? this.ctx.secret('CORTICO_JEV_API_KEY') : '');
+    if (!apiKey) throw new Error(`${source === 'openrouter' ? 'OpenRouter' : 'TypeSafe'} API key 未配置`);
+    const endpoint = source === 'openrouter'
+      ? 'https://openrouter.ai/api/alpha/decisions'
+      : 'https://api.typesafe.ai/v1/systemone';
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${apiKey}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ model: source === 'openrouter' ? '~typesafe/jev-latest' : 'jev-latest', state, questions }),
+      signal: AbortSignal.timeout(20_000),
+    });
+    if (!response.ok) throw new Error(`Jev 请求失败：HTTP ${response.status}`);
+    return response.json();
+  }
+}

package/src/multilingual-laya.ts

@@ -0,0 +1,85 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+
+const WORKER_FILE = fileURLToPath(new URL('../python/laya_multilingual_worker.py', import.meta.url));
+
+export interface MultilingualLayaModel {
+  systemOne(state: unknown, questions: unknown): Promise<unknown>;
+  close(): Promise<void>;
+}
+
+class PythonLayaModel implements MultilingualLayaModel {
+  private nextId = 0;
+  private readonly pending = new Map<string, { resolve(value: unknown): void; reject(error: Error): void }>();
+  private readonly ready: Promise<void>;
+  private readonly exited: Promise<void>;
+  private closed = false;
+
+  constructor(private readonly worker: ChildProcessWithoutNullStreams) {
+    this.ready = new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Laya multilingual 加载超时')), 120_000);
+      const lines = createInterface({ input: worker.stdout });
+      lines.on('line', (line) => {
+        let message: Record<string, unknown>;
+        try { message = JSON.parse(line) as Record<string, unknown>; }
+        catch { this.fail(new Error('Laya multilingual 返回了无效 JSON')); return; }
+        if (message.type === 'ready') {
+          clearTimeout(timeout);
+          resolve();
+          return;
+        }
+        const id = message.id;
+        if (typeof id !== 'string') return;
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        this.pending.delete(id);
+        if (message.ok === true) pending.resolve(message.result);
+        else pending.reject(new Error(typeof message.error === 'string' ? message.error : 'Laya multilingual 请求失败'));
+      });
+      worker.once('error', () => { clearTimeout(timeout); reject(new Error('Python 进程无法启动')); });
+      worker.once('exit', (code) => {
+        clearTimeout(timeout);
+        const error = new Error(`Laya multilingual 进程已退出：${code ?? 'unknown'}`);
+        reject(error);
+        this.fail(error);
+      });
+    });
+    this.exited = new Promise((resolve) => worker.once('exit', () => resolve()));
+  }
+
+  async waitUntilReady(): Promise<void> { await this.ready; }
+
+  async systemOne(state: unknown, questions: unknown): Promise<unknown> {
+    if (this.closed) throw new Error('Laya multilingual 已停止');
+    const id = String(++this.nextId);
+    const result = new Promise<unknown>((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    this.worker.stdin.write(`${JSON.stringify({ id, state, questions })}\n`);
+    return result;
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return this.exited;
+    this.closed = true;
+    this.worker.stdin.write(`${JSON.stringify({ type: 'close' })}\n`);
+    this.worker.stdin.end();
+    await this.exited;
+  }
+
+  private fail(error: Error): void {
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+}
+
+export async function startMultilingualLaya(pythonExecutable: string): Promise<MultilingualLayaModel> {
+  const worker = spawn(pythonExecutable, [WORKER_FILE], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+  });
+  worker.stderr.pipe(process.stderr);
+  const model = new PythonLayaModel(worker);
+  try { await model.waitUntilReady(); }
+  catch (error) { worker.kill(); throw error; }
+  return model;
+}

package/src/secret-file.ts

@@ -0,0 +1,23 @@
+import { spawn } from 'node:child_process';
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function ensureSecretPlaceholder(botDir: string, name: string): string {
+  const file = join(botDir, '.env');
+  const contents = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  if (!new RegExp(`^${name}=`, 'm').test(contents)) {
+    const line = `${contents && !contents.endsWith('\n') ? '\n' : ''}${name}=\n`;
+    if (existsSync(file)) appendFileSync(file, line);
+    else writeFileSync(file, line, { mode: 0o600 });
+  }
+  return file;
+}
+
+export function openSecretFile(file: string): Promise<void> {
+  const command = process.platform === 'win32' ? 'notepad.exe' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [file], { detached: true, stdio: 'ignore' });
+    child.once('error', reject);
+    child.once('spawn', () => { child.unref(); resolve(); });
+  });
+}

package/src/shared-laya.ts

@@ -0,0 +1,123 @@
+import { normalize } from 'node:path';
+
+export interface SharedLayaModel {
+  systemOne(state: unknown, questions: unknown): Promise<unknown>;
+  close(): Promise<void>;
+}
+
+export interface SharedLayaClient {
+  systemOne(state: unknown, questions: unknown): Promise<unknown>;
+  dispose(): Promise<void>;
+}
+
+interface Entry {
+  model: Promise<SharedLayaModel> | null;
+  closing: Promise<void> | null;
+  active: number;
+  queue: Promise<void>;
+  timer: ReturnType<typeof setTimeout> | null;
+  owners: Map<symbol, () => number>;
+}
+
+class LayaPool {
+  private readonly entries = new Map<string, Entry>();
+
+  create(
+    key: string,
+    load: () => Promise<SharedLayaModel>,
+    idleTtlMinutes: () => number,
+  ): SharedLayaClient {
+    const entry = this.entries.get(key) ?? {
+      model: null, closing: null, active: 0, queue: Promise.resolve(),
+      timer: null, owners: new Map<symbol, () => number>(),
+    };
+    this.entries.set(key, entry);
+    const owner = Symbol(key);
+    entry.owners.set(owner, idleTtlMinutes);
+    let disposed = false;
+    return {
+      systemOne: async (state, questions) => {
+        if (disposed) throw new Error('Laya client is closed');
+        entry.active++;
+        this.clearTimer(entry);
+        const previous = entry.queue;
+        let releaseQueue!: () => void;
+        entry.queue = new Promise<void>((resolve) => { releaseQueue = resolve; });
+        try {
+          await previous;
+          const model = await this.load(entry, load);
+          return await model.systemOne(state, questions);
+        } finally {
+          releaseQueue();
+          entry.active--;
+          if (entry.active === 0) await this.schedule(key, entry);
+        }
+      },
+      dispose: async () => {
+        if (disposed) return;
+        disposed = true;
+        entry.owners.delete(owner);
+        if (entry.active === 0) await this.schedule(key, entry);
+      },
+    };
+  }
+
+  private async load(entry: Entry, loader: () => Promise<SharedLayaModel>): Promise<SharedLayaModel> {
+    if (entry.closing) await entry.closing;
+    if (!entry.model) {
+      const loading = loader();
+      entry.model = loading;
+      void loading.catch(() => { if (entry.model === loading) entry.model = null; });
+    }
+    return entry.model;
+  }
+
+  private clearTimer(entry: Entry): void {
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.timer = null;
+  }
+
+  private async schedule(key: string, entry: Entry): Promise<void> {
+    this.clearTimer(entry);
+    const ttl = Math.max(0, ...[...entry.owners.values()].map((read) => read()));
+    if (entry.owners.size === 0 || ttl === 0) {
+      await this.release(key, entry);
+      return;
+    }
+    entry.timer = setTimeout(() => { void this.release(key, entry); }, ttl * 60_000);
+    entry.timer.unref();
+  }
+
+  private async release(key: string, entry: Entry): Promise<void> {
+    this.clearTimer(entry);
+    if (entry.active > 0) return;
+    const model = entry.model;
+    entry.model = null;
+    if (model) {
+      const closing = model.then((loaded) => loaded.close()).catch(() => undefined);
+      entry.closing = closing;
+      await closing;
+      if (entry.closing === closing) entry.closing = null;
+    } else if (entry.closing) {
+      await entry.closing;
+    }
+    if (entry.owners.size === 0 && entry.active === 0 && !entry.model) this.entries.delete(key);
+  }
+}
+
+const POOL = Symbol.for('cortico.local-laya.pool.v1');
+
+export function sharedLayaPool(): LayaPool {
+  const holder = globalThis as unknown as Record<symbol, LayaPool | undefined>;
+  return holder[POOL] ??= new LayaPool();
+}
+
+export function isolatedLayaPool(): LayaPool {
+  return new LayaPool();
+}
+
+export function layaRuntimeKey(variant: 'english' | 'multilingual', pythonExecutable = ''): string {
+  if (variant === 'english') return 'english:@receptron/laya@0.1.2';
+  const path = normalize(pythonExecutable);
+  return `multilingual:convaiinnovations/laya:${process.platform === 'win32' ? path.toLowerCase() : path}`;
+}

package/src/world.ts

@@ -0,0 +1,187 @@
+import { randomInt } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import type { ToolDef, ToolOutcome, World, WorldConsoleDecl, WorldHost } from 'cortico/core/types.ts';
+import type { WorldContext } from 'cortico/world.ts';
+import { classify, difficultyFromProbability, formatChecks } from './check.ts';
+import {
+  SIMPLE_TRPG_CHECK_CONFIG_GROUP,
+  SIMPLE_TRPG_CHECK_OPENROUTER_SECRET,
+  SIMPLE_TRPG_CHECK_TYPESAFE_SECRET,
+  SIMPLE_TRPG_CHECK_LEGACY_OPENROUTER_SECRET,
+  SIMPLE_TRPG_CHECK_LEGACY_TYPESAFE_SECRET,
+  type SimpleTrpgCheckConfigSection,
+} from './config.ts';
+import { SystemOneSkillScorer, type SkillScorer } from './model.ts';
+import { ensureSecretPlaceholder, openSecretFile } from './secret-file.ts';
+
+const ENV_PROMPT_FILE = fileURLToPath(new URL('./ENV_PROMPT.md', import.meta.url));
+
+export class SimpleTrpgCheckWorld implements World {
+  readonly id = 'simple-trpg-check';
+  private readonly scorer: SkillScorer;
+  private modelState: 'offline' | 'loading' | 'online' | 'error' = 'offline';
+  private modelSignature = '';
+  private modelRequestId = 0;
+
+  private hasJevKey(): boolean {
+    const source = this.ctx.cfg.jevSource;
+    return !!(this.ctx.secret(source === 'openrouter'
+      ? SIMPLE_TRPG_CHECK_OPENROUTER_SECRET : SIMPLE_TRPG_CHECK_TYPESAFE_SECRET)
+      || this.ctx.secret(source === 'openrouter'
+        ? SIMPLE_TRPG_CHECK_LEGACY_OPENROUTER_SECRET : SIMPLE_TRPG_CHECK_LEGACY_TYPESAFE_SECRET)
+      || (source === 'typesafe' && this.ctx.secret('CORTICO_JEV_API_KEY')));
+  }
+
+  constructor(
+    private readonly ctx: WorldContext<SimpleTrpgCheckConfigSection>,
+    scorer?: SkillScorer,
+    private readonly roll: () => number = () => randomInt(1, 101),
+    private readonly openFile: (path: string) => void | Promise<void> = openSecretFile,
+  ) {
+    this.scorer = scorer ?? new SystemOneSkillScorer(ctx);
+  }
+
+  envPromptVars(): Record<string, string> {
+    return {
+      'simpleTrpgCheck.languageRule': this.ctx.cfg.forceMultilingual
+        ? '调用此工具时，scenario 和 skill_lists 必须用英文填写。'
+        : '',
+    };
+  }
+
+  tools(): ToolDef[] {
+    return [{
+      name: 'simple_trpg_check_roll',
+      description: '对 scenario 中的目标并行评估每项 skill_lists 的成功把握，再逐项掷 1–100。返回 [判定/难度] 与固定的结果建议；模型失败时不掷骰。',
+      tags: ['act'],
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          scenario: {
+            type: 'string',
+            minLength: 1,
+            description: '角色如何用这些技能达成什么目标，相关情境；可写熟练程度或身体条件。',
+          },
+          skill_lists: {
+            type: 'array',
+            minItems: 1,
+            items: { type: 'string', minLength: 1 },
+            description: '按判定顺序列出技能名称。',
+          },
+        },
+        required: ['scenario', 'skill_lists'],
+      },
+      handler: (args) => this.runCheck(args),
+    }];
+  }
+
+  console(): WorldConsoleDecl {
+    const source = this.ctx.cfg.jevSource;
+    const keySet = this.hasJevKey();
+    const signature = this.currentModelSignature();
+    const modelState = signature === this.modelSignature ? this.modelState : 'offline';
+    return {
+      config: [SIMPLE_TRPG_CHECK_CONFIG_GROUP],
+      lamps: [{
+        label: '判定模型',
+        state: modelState,
+        hint: modelState === 'online' ? '最近一次模型请求成功' : modelState === 'error'
+          ? '最近一次模型请求失败' : modelState === 'loading' ? '正在请求模型' : '尚未成功请求模型',
+      }],
+      badges: this.ctx.cfg.backend === 'jev'
+        ? [{ label: source === 'openrouter' ? 'OpenRouter' : 'TypeSafe', value: keySet ? '密钥已配置' : '密钥未配置', tone: keySet ? 'on' : 'off' }]
+        : [{ label: '判定模型', value: this.ctx.cfg.backend }],
+      panels: [
+        { id: 'connection-test', title: '测试连接', slot: 'model-test' },
+        { id: 'credentials', title: 'Jev 密钥', slot: 'jev-key' },
+      ] as unknown as WorldConsoleDecl['panels'],
+      invoke: async (panel, method, args) => {
+        if (panel === 'connection-test' && method === 'testConnection') {
+          try {
+            await this.assess('A character climbs a waist-high wall to reach the other side.', ['climbing']);
+            return { ok: true };
+          } catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error) };
+          }
+        }
+        if (panel !== 'credentials') throw new Error('未知面板');
+        if (method === 'state') {
+          return { backend: this.ctx.cfg.backend, source: this.ctx.cfg.jevSource, keySet: this.hasJevKey() };
+        }
+        if (method === 'openKeyFile') {
+          const source = args[0];
+          if (source !== this.ctx.cfg.jevSource || this.ctx.cfg.backend !== 'jev') {
+            throw new Error('Jev 来源已改变，请重试');
+          }
+          const secretName = this.ctx.cfg.jevSource === 'openrouter'
+            ? SIMPLE_TRPG_CHECK_OPENROUTER_SECRET
+            : SIMPLE_TRPG_CHECK_TYPESAFE_SECRET;
+          const file = ensureSecretPlaceholder(this.ctx.botDir, secretName);
+          await this.openFile(file);
+          return { file };
+        }
+        throw new Error('未知操作');
+      },
+      promptDocs: [{
+        key: 'worlds.simple-trpg-check.envPrompt',
+        title: 'Simple TRPG Check · 环境提示词',
+        description: '何时调用技能判定，以及如何填写情境和技能。',
+        path: ENV_PROMPT_FILE,
+        role: 'envPrompt',
+        vars: [{ name: 'simpleTrpgCheck.languageRule', description: '英文输入开关的当前要求。' }],
+      }],
+    };
+  }
+
+  async start(_host: WorldHost): Promise<void> {}
+  async stop(): Promise<void> {
+    this.modelState = 'offline';
+    await this.scorer.close();
+  }
+
+  private currentModelSignature(): string {
+    const { backend, jevSource, pythonExecutable } = this.ctx.cfg;
+    return `${backend}|${backend === 'jev' ? jevSource : pythonExecutable}`;
+  }
+
+  private async assess(scenario: string, skills: string[]): Promise<number[]> {
+    const signature = this.currentModelSignature();
+    const requestId = ++this.modelRequestId;
+    this.modelSignature = signature;
+    this.modelState = 'loading';
+    try {
+      const probabilities = await this.scorer.score(scenario, skills);
+      if (probabilities.length !== skills.length) throw new Error('模型返回的技能答案数量不匹配');
+      probabilities.forEach(difficultyFromProbability);
+      if (signature !== this.currentModelSignature()) throw new Error('判定模型配置已改变，请重试');
+      if (requestId === this.modelRequestId) this.modelState = 'online';
+      return probabilities;
+    } catch (error) {
+      if (requestId === this.modelRequestId && signature === this.currentModelSignature()) this.modelState = 'error';
+      throw error;
+    }
+  }
+
+  private async runCheck(args: Record<string, unknown>): Promise<ToolOutcome> {
+    try {
+      const scenario = args.scenario;
+      const skillLists = args.skill_lists;
+      if (typeof scenario !== 'string' || !scenario.trim()) throw new Error('scenario 不能为空');
+      if (!Array.isArray(skillLists) || skillLists.length === 0 || skillLists.some(
+        (skill) => typeof skill !== 'string' || !skill.trim(),
+      )) throw new Error('skill_lists 必须是非空技能名称列表');
+      const skills = skillLists as string[];
+      const probabilities = await this.assess(scenario, skills);
+      const difficulties = probabilities.map(difficultyFromProbability);
+      const checks = skills.map((skill, index) => {
+        const difficulty = difficulties[index]!;
+        const roll = this.roll();
+        return { skill, difficulty, roll, result: classify(roll, difficulty) };
+      });
+      return { text: formatChecks(checks) };
+    } catch (error) {
+      return { text: `技能判定失败：${error instanceof Error ? error.message : String(error)}`, failed: true };
+    }
+  }
+}