@xiaobuyu/nodesign 0.0.6 → 0.0.8

package/server/api/turn.js

@@ -42,24 +42,31 @@ import {
 import { createRun } from '../engine/runs/store.js';
 import { runSession } from '../engine/agent/session-loop.js';
 import {
-  cancelRun, provideAnswer, getQuery, provideElicitation, hasActiveQuerySession, getQuerySession, closeQuerySession, setSessionPermissionMode, getSessionIdByRunId,
+  cancelRun, provideAnswer, getQuery, provideElicitation, hasActiveQuerySession, getQuerySession, closeQuerySession, setSessionPermissionMode,
 } from '../engine/runs/active-runs.js';
 import { pushUserMessage, getQueueDepth } from '../engine/runs/turn-relay.js';
 import { applySessionModel, resolveSessionModel } from '../engine/agent/session-model.js';
 import { lruGet, lruPut, inflightTurns, INFLIGHT_RETENTION_MS } from './turn-inflight.js';
-import { allowedModelsFor, isModelLockedFor, defaultModelFor, modelIsFree, resolveSdkSpoofModel, hasSubscriptionAccess, crossLaneSwitchReason } from '../engine/agent/model-context.js';
+import { allowedModelsFor, isModelLockedFor, defaultModelFor, modelIsFree, hasSubscriptionAccess, modelSwitchRejection, resolveModelRoute } from '../engine/agent/model-context.js';
 import { AsyncQueue } from '../lib/async-queue.js';
 import { checkQuota, checkFreeQuota, checkConcurrency, fmtUsd } from '../lib/quota.js';
 import { shouldModerate, moderateText, recordViolation, levelFor } from '../lib/moderation.js';
 import { getProjectBus } from '../ws/broker.js';
 import { Events } from '../engine/agent/events.js';
 import { readPendingSummary } from './pending-changes.js';
-import { pendingRewinds } from './sessions.js';
+import { pendingRewinds } from './sessions-rewind.js';
 import { platform } from '../runtime/platform.js';
 import { composeUserMessage } from './turn-compose.js';
 
 const router = express.Router();
 
+/**
+ * SDK uuid 形态。用户消息的 id 在三处必须是**同一个** 36-char uuid：jsonl 里那条
+ * user 记录的 uuid、rewindFiles(userMessageId) 的入参、fork 的 upToMessageId。
+ * 前端同一份判据在 web/src/components/chat/Message.jsx（改一处记得对另一处）。
+ */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
 /**
  * Emit run.permission_mode_changed —— 广播 SDK 实际 permissionMode 的变化。唯一的
  * 切换路径（turn 入口 mode 校正）调完 setPermissionMode 后 emit 一次。
@@ -95,7 +102,7 @@ router.post('/:pid/turn', async (req, res, next) => {
     const project = guardProject(req, res);
     if (!project) return;
 
-    const { chat, attachments, skillId, sessionId, permissionMode, requestId, raw } = req.body || {};
+    const { chat, attachments, skillId, sessionId, permissionMode, requestId, raw, userMessageUuid } = req.body || {};
     // 只发附件不打字也是一条完整消息（2026-08-17，issue #1 第 8 条）：拖张参考图
     // 进来就该能发，逼用户补一句"看看这个"是白要的动作。
     // 空文字 **且** 空附件才是空消息 —— 那个仍然拦。
@@ -112,14 +119,14 @@ router.post('/:pid/turn', async (req, res, next) => {
     if (typeof requestId === 'string' && requestId) {
       const cached = lruGet(requestId);
       if (cached && cached.pid === project.id) {
-        return res.status(202).json({ runId: cached.runId, sessionId: cached.sessionId, deduped: true });
+        return res.status(202).json({ runId: cached.runId, sessionId: cached.sessionId, userMessageId: cached.userMessageId, deduped: true });
       }
       const inflight = inflightTurns.get(requestId);
       if (inflight) {
         try {
           const r = await inflight;
           if (r && r.pid === project.id) {
-            return res.status(202).json({ runId: r.runId, sessionId: r.sessionId, deduped: true });
+            return res.status(202).json({ runId: r.runId, sessionId: r.sessionId, userMessageId: r.userMessageId, deduped: true });
           }
         } catch { /* first POST failed → fall through 让本 POST 重新跑 */ }
       }
@@ -183,20 +190,27 @@ router.post('/:pid/turn', async (req, res, next) => {
     // 解析出来的模型一律过白名单（不只 body.model）：旧覆盖/资格收回/无 select 裸名都在此拦（fable P0）
     if (isModelLockedFor(modelUser, turnModel)) {
       return res.status(403).json({
-        error: `这个模型（${turnModel}）仅限 Pro 档，暂未对外开放。换成免费模型继续`,
+        error: msg(req, '这个模型（{model}）仅限 Pro 档，暂未对外开放。换成免费模型继续', { model: turnModel }),
         code: 'MODEL_LOCKED', model: turnModel,
       });
     }
     if (!allowedModelsFor(modelUser).some((m) => m.id === turnModel)) {   // 清单整个为空（本地版没 key/没登录/没插槽）→ 指路设置页，别让人去选择器里找
-      return res.status(403).json(allowedModelsFor(modelUser).length ? { error: `这个会话指向的模型（${turnModel}）现在不可用，请在模型选择器里换一个`, code: 'MODEL_NOT_ALLOWED', model: turnModel } : { error: '还没有可用的模型：到「设置」填 API Key（或本机 claude login），或者配一个模型插槽', code: 'NO_MODEL_CONFIGURED', model: turnModel });
-    }
-    if (requestedModelEarly && sessionModelEarly.override && crossLaneSwitchReason(sessionModelEarly.override, requestedModelEarly)) {
-      return res.status(409).json({ error: crossLaneSwitchReason(sessionModelEarly.override, requestedModelEarly), code: 'LANE_SWITCH' });
+      return res.status(403).json(allowedModelsFor(modelUser).length ? { error: msg(req, '这个会话指向的模型（{model}）现在不可用，请在模型选择器里换一个', { model: turnModel }), code: 'MODEL_NOT_ALLOWED', model: turnModel } : { error: msg(req, '还没有可用的模型：到「设置」填 API Key（或本机 claude login），或者配一个模型插槽'), code: 'NO_MODEL_CONFIGURED', model: turnModel });
     }
+    // ⛔ 08-25 修：原来这条带着 `sessionModelEarly.override &&`，于是**跑在全局默认上的会话（override=null）
+    // 整个逃过检查** —— 而站上默认恰恰是免费的 Ox（openai-chat），正是这条闸要防的那一头。
+    // 改成拿**当前有效模型**（override → env → 兜底，resolveSessionModel 已经算好）去比；新会话不拦，
+    // 它还没有历史，而这条闸防的是历史里没有 signature 的 thinking 块被回传给真 Anthropic。
+    // ⚠️ 已知的一处宽严不匹配：这里的"新会话"判据是 `!resumeSessionId`，而不是 sessions.js 那条 PUT 用的
+    // "jsonl 存不存在"。差别只在一种情况——**会话建了但一次没跑过、第一轮就显式换到另一通路**，
+    // 这里会多拦一次（409 说"新开一个会话"，人照做就没事）。sessionRoot 要到本函数后半段才拿得到，
+    // 为这一种情况把 ensureSessionWorkspace 提前不划算。
+    const laneWhy = modelSwitchRejection({ from: sessionModelEarly.model, to: requestedModelEarly, hasHistory: !isNewSession });
+    if (laneWhy) return res.status(409).json({ error: laneWhy, code: 'LANE_SWITCH' });
     if (modelIsFree(turnModel)) {
       const fq = checkFreeQuota(req.user);
       if (!fq.ok) {
-        return res.status(429).json({ error: `今天的免费轮次用完了（${fq.used} / ${fq.limit}），明天零点刷新`, code: 'QUOTA_EXCEEDED', kind: fq.kind, used: fq.used, limit: fq.limit });
+        return res.status(429).json({ error: msg(req, '今天的免费轮次用完了（{used} / {limit}），明天零点刷新', { used: fq.used, limit: fq.limit }), code: 'QUOTA_EXCEEDED', kind: fq.kind, used: fq.used, limit: fq.limit });
       }
     }
     const quota = modelIsFree(turnModel) ? { ok: true } : checkQuota(req.user);
@@ -214,9 +228,11 @@ router.post('/:pid/turn', async (req, res, next) => {
       });
     }
     // 并发：只拦"会立刻开跑"的 turn；session 正忙时这条消息进排队（既有串行语义，
-    // 不产生新并发）。免费行不受全局固定数限制，只受内存闸（quota.js）
+    // 不产生新并发）。**非订阅行**不受全局固定数限制，只受内存闸 + 防失控上限（quota.js）。
+    // ⚠️ 判据是"花不花站主订阅"，不是"这一轮花不花钱"（08-30 改）：那个固定数 3 护的是订阅，
+    // 一条 $0.015/M 的 API 行塞进那一档只会把站点默认路径的天花板从 12 砍到 3。
     if (!getQuerySession(sid)?.currentRunId) {
-      const gate = checkConcurrency(req.user, { free: modelIsFree(turnModel) });
+      const gate = checkConcurrency(req.user, { offSubscription: resolveModelRoute(turnModel).mode === 'api' });
       if (!gate.ok) {
         return res.status(429).json({ error: gate.message, code: gate.code });
       }
@@ -302,6 +318,18 @@ router.post('/:pid/turn', async (req, res, next) => {
       console.info(`[turn.compose] sid=${sid.slice(0, 8)} blocks=[${summary.join(', ')}]`);
     }
 
+    // 这条用户消息的 uuid（2026-08-30「回退标识要刷新才出现」案）。
+    //
+    // 它是 SDKUserMessage.uuid，CLI 会**原样**写进 jsonl（探针实证：push 时盖的
+    // uuid 与 jsonl 里那条 user 记录的 uuid 一致），而 rewindFiles / fork 的
+    // upToMessageId / truncateJsonlAtMessage 认的都是 jsonl 里那个 uuid。
+    //
+    // 以前它由 pushUserMessage 在 202 之后临时生成（新会话首条甚至不盖，由 CLI 自己
+    // 生成），前端无从知晓 → 乐观插入的气泡只能用本地 `msg_xxx` 做 id → 回退/分叉
+    // 按钮的 UUID 判据不认它 → **必须刷新页面**等 hydrate 从 jsonl 读回真 uuid 才出现。
+    // 现在改成前端先生成、随请求带来（老前端不带则这里生成），202 也回传一份。
+    const userMsgUuid = UUID_RE.test(String(userMessageUuid || '')) ? userMessageUuid : randomUUID();
+
     // 创建 run（pending）— per-turn record，displayText 落 brief 字段做审计
     const run = createRun({
       skillId: finalSkillId, brief: displayText, projectId: project.id,
@@ -312,21 +340,24 @@ router.post('/:pid/turn', async (req, res, next) => {
     // 同时 resolve in-flight Promise 通知正在 await 的并发 POST，5s 后清 in-flight
     // entry（让 LRU 接管后续 dedup 查询）。
     if (typeof requestId === 'string' && requestId) {
-      lruPut(requestId, { pid: project.id, runId: run.id, sessionId: sid });
+      lruPut(requestId, { pid: project.id, runId: run.id, sessionId: sid, userMessageId: userMsgUuid });
       if (inflightResolve) {
-        inflightResolve({ pid: project.id, runId: run.id, sessionId: sid });
+        inflightResolve({ pid: project.id, runId: run.id, sessionId: sid, userMessageId: userMsgUuid });
       }
       setTimeout(() => inflightTurns.delete(requestId), INFLIGHT_RETENTION_MS);
     }
 
     // 立即返回，agent 后台跑
-    res.status(202).json({ runId: run.id, sessionId: sid });
+    res.status(202).json({ runId: run.id, sessionId: sid, userMessageId: userMsgUuid });
     const bus = getProjectBus(project.id);
 
     const sdkUserMessage = {
       type: 'user',
       message: { role: 'user', content: blocks },
       parent_tool_use_id: null,
+      // 两条路径都盖：pushUserMessage 走 runIdByUuid 认领（它见 uuid 已在就不再生成），
+      // startNewRunSession 那条不进认领表（claimRunByUuid 返 null，照旧走 initialRunId）。
+      uuid: userMsgUuid,
     };
 
     if (hasActiveQuerySession(sid)) {
@@ -587,78 +618,11 @@ router.post('/:pid/runs/:runId/rewind', async (req, res, next) => {
   } catch (err) { next(err); }
 });
 
-/**
- * POST /api/projects/:pid/runs/:runId/model
- *
- * 运行中切 model（SDK query.setModel，当场对下一次 LLM 调用生效）。
- *
- * **目前只有 API 能到这里**：前端 picker 在 turn 运行中是禁用的，它走
- * PUT /sessions/:sid/model（那条等空闲才重启 query）。这条留着是因为"turn 跑到
- * 一半换模型"是它独有的能力，PUT 那条按设计做不到。前端那个没人调的 Turn.setModel
- * 绑定已删（doc 里还写着 kimi 时代的 model 名，留着只会误导下一个人）。
- *
- * 2026-07-30：切完**必须同时落 session-config**。原来这条只改运行时不写文件，
- * 于是"当前这轮是 Opus、下次 resume 变回 Sonnet"，而且界面无从得知；跟另外两条
- * 写模型的路加起来，同一个事实有三个互不知情的写者。现在统一走 applySessionModel，
- * 它自己会判断要不要重启空闲 query（这里 query 正在跑，不会重启）。
- *
- * Body: { model: string | null }  - null = 清掉覆盖回到全局默认
- */
-router.post('/:pid/runs/:runId/model', async (req, res, next) => {
-  try {
-    const project = guardProject(req, res);
-    if (!project) return;
-    if (!guardRunInProject(req, res)) return;
-
-    const { runId } = req.params;
-    const { model } = req.body || {};
-    if (model !== null && model !== undefined && typeof model !== 'string') {
-      return res.status(400).json({ error: 'model must be string or null' });
-    }
+import { hotSwitchModelHandler } from './turn-model-switch.js';
+import { msg } from '../shared/messages.js';
 
-    // 08-21：热切路以前不过白名单（任意字符串直达 SDK）。与 PUT /sessions/:sid/model 同口径
-    if (typeof model === 'string' && model.trim()) {
-      const modelUser = modelUserFor(req, project);   // 资格按项目 owner 算（_guard.js）
-      if (isModelLockedFor(modelUser, model.trim())) {
-        return res.status(403).json({ error: '这个模型仅限 Pro 档，暂未对外开放', code: 'MODEL_LOCKED', model: model.trim() });
-      }
-      if (!allowedModelsFor(modelUser).some((m) => m.id === model.trim())) {
-        return res.status(400).json({ error: `unknown model: ${model}`, code: 'UNKNOWN_MODEL' });
-      }
-      const sidForLane = getSessionIdByRunId(runId);
-      if (sidForLane) {
-        const cur = await resolveSessionModel(getSessionMetaDir(project.id, sidForLane));
-        const why = crossLaneSwitchReason(cur.model, model.trim());
-        if (why) return res.status(409).json({ error: why, code: 'LANE_SWITCH' });
-      }
-    }
-
-    const query = getQuery(runId);
-    if (!query) {
-      return res.status(404).json({
-        error: 'run not active',
-        code: 'RUN_NOT_ACTIVE',
-      });
-    }
-    if (typeof query.setModel !== 'function') {
-      return res.status(501).json({
-        error: 'SDK query handle missing setModel method',
-        code: 'METHOD_NOT_AVAILABLE',
-      });
-    }
-
-    const sid = getSessionIdByRunId(runId);
-    // API 行喂 SDK 的是 spoof 名（session-loop 同款），appModel 本身 binary 不认识
-    await query.setModel(model ? resolveSdkSpoofModel(model.trim()) : undefined);
-    // 运行时切完再落盘：setModel 失败就不该留下"配置说切了"的假象
-    let persisted = null;
-    if (sid) {
-      await ensureSessionWorkspace(project.id, sid);
-      persisted = await applySessionModel(sid, getSessionMetaDir(project.id, sid), model ?? null, 'runtime');
-    }
-    res.json({ ok: true, model: persisted?.model ?? model, override: persisted?.override ?? null });
-  } catch (err) { next(err); }
-});
+/** 运行中热切模型（实现连同它那三道闸搬去了 turn-model-switch.js） */
+router.post('/:pid/runs/:runId/model', hotSwitchModelHandler);
 
 
 // 注：POST /image-approval 路由已删除（2026-05-06）。原本配 ImageApprovalBanner

package/server/auth/middleware.js

@@ -15,9 +15,11 @@ import express from 'express';
 import {
   authEnabled, mintToken, requestUser, cookieSerialize, cookieClear,
 } from './session.js';
-import { getCredential, verifyPassword, getUserById, registerUser, openRegistrationEnabled } from './users-store.js';
+import { getCredential, verifyPassword, getUserById, registerUser, openRegistrationEnabled, updateUser } from './users-store.js';
+import { LOCALES, isLocale } from '../shared/locales.js';
 import { makeRateWindow } from '../lib/rate-window.js';
 import { platform } from '../runtime/platform.js';
+import { msg } from '../shared/messages.js';
 
 const MAX_FAILS = 10;
 const LOCK_MS = 15 * 60 * 1000;
@@ -56,7 +58,8 @@ function recordFail(ip) {
   failures.set(ip, next);
 }
 
-const publicUser = (u) => (u ? { id: u.id, username: u.username, role: u.role } : null);
+// locale：界面语言偏好，null = 没表过态（前端这时落浏览器语言，见 lib/i18n.js detect）
+const publicUser = (u) => (u ? { id: u.id, username: u.username, role: u.role, locale: u.locale ?? null } : null);
 
 export const authRouter = express.Router();
 
@@ -66,12 +69,32 @@ authRouter.get('/status', (req, res) => {
   res.json({ required: authEnabled(), authed: !!user, user: publicUser(user), openRegistration: openRegistrationEnabled(), profile: platform.profile });
 });
 
+/**
+ * 记住界面语言（2026-08-26 i18n）。
+ *
+ * 只有登录用户才写账号；没登录的人切语言只落 localStorage（前端自己管），
+ * 这里 401 让前端知道"没存上"，但前端**不该因此把切换器禁掉** —— 登录墙外面
+ * 也要能换语言，不然英文用户连注册按钮都读不懂。
+ *
+ * body: { locale: 'zh-CN' | 'en' | null }。null = 清掉偏好，回到跟浏览器走。
+ */
+authRouter.put('/locale', (req, res) => {
+  const user = requestUser(req);
+  if (!user) return res.status(401).json({ error: msg(req, '没登录，语言只记在这台机器上') });
+  const { locale } = req.body || {};
+  if (locale !== null && !isLocale(locale)) {
+    return res.status(400).json({ error: msg(req, 'locale 需为 {allowed} 或 null', { allowed: LOCALES.join(' / ') }) });
+  }
+  updateUser(user.id, { locale });
+  res.json({ ok: true, locale: locale ?? null });
+});
+
 authRouter.post('/login', (req, res) => {
   if (!authEnabled()) return res.json({ ok: true, note: 'auth disabled' });
 
   const ip = clientIp(req);
   const waitMin = locked(ip);
-  if (waitMin) return res.status(429).json({ error: `尝试次数过多，${waitMin} 分钟后再试` });
+  if (waitMin) return res.status(429).json({ error: msg(req, '尝试次数过多，{waitMin} 分钟后再试', { waitMin }) });
 
   const { username, password } = req.body || {};
   const cred = typeof username === 'string' ? getCredential(username.trim()) : null;
@@ -80,7 +103,7 @@ authRouter.post('/login', (req, res) => {
     && verifyPassword(typeof password === 'string' ? password : '', cred.passwordHash);
   if (!ok) {
     recordFail(ip);
-    return res.status(401).json({ error: '用户名或密码错误' });
+    return res.status(401).json({ error: msg(req, '用户名或密码错误') });
   }
 
   failures.delete(ip);
@@ -91,13 +114,13 @@ authRouter.post('/login', (req, res) => {
 authRouter.post('/register', (req, res) => {
   const ip = clientIp(req);
   const waitMin = locked(ip);
-  if (waitMin) return res.status(429).json({ error: `尝试次数过多，${waitMin} 分钟后再试` });
+  if (waitMin) return res.status(429).json({ error: msg(req, '尝试次数过多，{waitMin} 分钟后再试', { waitMin }) });
 
   const { username, password, inviteCode } = req.body || {};
   const hasInvite = typeof inviteCode === 'string' && inviteCode.trim();
   const perIpLimit = Number(process.env.NODESIGN_REGISTER_PER_IP_PER_DAY) || 5;
   if (!hasInvite && registerWindow.count(ip) >= perIpLimit) {
-    return res.status(429).json({ error: '这个网络今天开的号太多了，明天再来', code: 'REGISTER_RATE_LIMITED' });
+    return res.status(429).json({ error: msg(req, '这个网络今天开的号太多了，明天再来'), code: 'REGISTER_RATE_LIMITED' });
   }
   try {
     const user = registerUser({

package/server/auth/tier.js

@@ -35,16 +35,29 @@ export const PLANS = Object.freeze(['pro', 'basic']);
  *   localGen          本地产线资格（paint_still / roll_film / 演出端点 / 本地无审查模型行）；
  *                     pro 档还要叠 allowLocalGen 批准，见 localGenApproved
  *   publishSite       publish_site 上 CF Pages（占站主四级域名 + 每账户 100 站硬上限）
- *   moderationDefault 外审默认档（用户没被显式钉档时生效）
+ *   moderationDefault    订阅通路的外审默认档（用户没被显式钉档时生效）
+ *   moderationDefaultApi API 通路（非订阅模型）的外审默认档 —— **两条通路各一个默认**
  *   webSearchDailyCap basic 档 web_search 每日上限（null = 不限）；env NODESIGN_BASIC_WEB_SEARCH_PER_DAY 可调
+ *
+ * ⭐⭐ **外审默认档 08-30 拆成两个**（用户拍板：「新账户默认按订阅严格、其他模型关闭」）。
+ * 在此之前一格值同时管两条通路，于是"订阅要严、非订阅不审"这个口径根本表达不出来 ——
+ * 只能一个人一个人去 admin 台钉 moderation_level_api，钉过 41 个号，钉漏的还在按 strict 跑。
+ * 现在两条通路各有各的默认，口径的家在这张表里，不在 88 行用户数据里。
+ *
+ * 为什么这个口径讲得通：外审那道闸（lib/moderation.js）的存在理由是**违规消息不能进站主的
+ * Claude 订阅**（骑的是站主账号，封号风险在站主头上）。非订阅模型走的是各家 API，
+ * 各家自己有内容策略、出事也是那家的账 —— 我们再叠一层 GPT 外审只是在误伤创作。
+ * ⚠️ 连带效果不止于"不审"：同一格值也管 prelude 的成人段（agent/system-prompts.js），
+ * 'off' 那档写的是「成人内容明确允许，不用迂回」。改这一格 = 同时改口径和提示词。
  */
 const CAPABILITIES = Object.freeze({
-  admin: Object.freeze({ subscription: true, webSearch: true, imageGen: true, localGen: true, publishSite: true, moderationDefault: 'off', webSearchDailyCap: null }),
+  admin: Object.freeze({ subscription: true, webSearch: true, imageGen: true, localGen: true, publishSite: true, moderationDefault: 'off', moderationDefaultApi: 'off', webSearchDailyCap: null }),
   // 08-21 晚用户拍板「所有审查都开到严格」：pro 默认档 loose → strict（admin 仍免审）
-  pro: Object.freeze({ subscription: true, webSearch: true, imageGen: true, localGen: true, publishSite: true, moderationDefault: 'strict', webSearchDailyCap: null }),
+  // 08-30 起这条只管订阅通路；API 通路见 moderationDefaultApi
+  pro: Object.freeze({ subscription: true, webSearch: true, imageGen: true, localGen: true, publishSite: true, moderationDefault: 'strict', moderationDefaultApi: 'off', webSearchDailyCap: null }),
   // 08-21 深夜用户拍板：basic 是今后唯一对外分发的档（pro 不再新发，只手动给）；basic 可用 Ox 免费行 + OpenCode Go 付费行 +
   // 生图（$0.20/张计入同一本账），每人每天 $5 总额度（注册时写 dailyCostLimitUsd，见 basicDefaultDailyUsd）；订阅 Claude / 本地产线 / 发布仍不开
-  basic: Object.freeze({ subscription: false, webSearch: true, imageGen: true, localGen: false, publishSite: false, moderationDefault: 'strict', webSearchDailyCap: 'env' }),
+  basic: Object.freeze({ subscription: false, webSearch: true, imageGen: true, localGen: false, publishSite: false, moderationDefault: 'strict', moderationDefaultApi: 'off', webSearchDailyCap: 'env' }),
 });
 
 /** basic 档注册时写入的每日总额度（美元）。env NODESIGN_BASIC_DEFAULT_DAILY_USD；0 或非法 = 不写（走全局默认日限） */
@@ -75,10 +88,17 @@ export function can(user, capability) {
   return CAPABILITIES[tier][capability] === true;
 }
 
-/** 外审默认档（off | loose | strict）。null 用户 → 'off' 的老语义留给 moderation.js 自己判。 */
-export function defaultModerationLevel(user) {
+/**
+ * 外审默认档（off | loose | strict）。null 用户 → 'off' 的老语义留给 moderation.js 自己判。
+ *
+ * @param {object|null} user
+ * @param {'subscription'|'api'} [knob]  哪条通路的默认。**不给 = 订阅** —— 拼错 / 没传
+ *   只能落到管站主账号的那一边，不能落到更松的一边（同 moderationKnobFor 的口径）。
+ */
+export function defaultModerationLevel(user, knob = 'subscription') {
   const tier = tierOf(user);
-  return tier ? CAPABILITIES[tier].moderationDefault : 'strict';
+  const key = knob === 'api' ? 'moderationDefaultApi' : 'moderationDefault';
+  return tier ? CAPABILITIES[tier][key] : 'strict';
 }
 
 /** basic 档 web_search 每日上限；其它档 null（不限）。 */

package/server/auth/users-store.js

@@ -19,6 +19,7 @@
 import crypto from 'node:crypto';
 import db from '../engine/runs/store.js';
 import { PLANS, basicDefaultDailyUsd } from './tier.js';
+import { LOCALES } from '../shared/locales.js';
 import { platform } from '../runtime/platform.js';
 
 /**
@@ -116,6 +117,13 @@ if (!userCols.has('plan')) {
   const n = db.prepare("UPDATE users SET plan = 'pro' WHERE allow_subscription = 1").run().changes;
   console.log(`[users-store] users.plan column added（${n} 个账号按 allow_subscription 迁成 pro，其余 basic）`);
 }
+// 08-26 i18n：界面语言偏好。NULL = 没表过态（前端落浏览器语言），'zh-CN' / 'en' = 显式选过。
+// 不给 NOT NULL DEFAULT：存量账号必须是"没表过态"，不能被当成选了中文 —— 一个用惯英文
+// 浏览器的老用户下次进来该看见英文，而不是被这次迁移钉死在中文上。
+if (!userCols.has('locale')) {
+  db.exec('ALTER TABLE users ADD COLUMN locale TEXT');
+  console.log('[users-store] users.locale column added');
+}
 
 const inviteCols = new Set(db.prepare('PRAGMA table_info(invites)').all().map(c => c.name));
 if (!inviteCols.has('grant_lifetime_usd')) {
@@ -171,6 +179,7 @@ function rowToUser(row) {
     allowLocalGen: !!row.local_gen,                   // 本地产线逐人批准（叠在档位之上；见 auth/tier.js localGenApproved）
     plan: row.plan === 'pro' ? 'pro' : 'basic',       // 档位真相源：pro（邀请码）| basic（公开注册）；admin 看 role。能力问 auth/tier.js
     disabled: !!row.disabled,
+    locale: row.locale || null,                      // 界面语言偏好；null = 没表过态，前端落浏览器语言
     inviteCode: row.invite_code || null,
     createdAt: row.created_at,
   };
@@ -215,13 +224,17 @@ export function listUsers() {
   return db.prepare('SELECT * FROM users ORDER BY created_at ASC').all().map(rowToUser);
 }
 
-export function updateUser(id, { disabled, dailyTokenLimit, dailyCostLimitUsd, lifetimeCostLimitUsd, role, moderationLevel, moderationLevelApi, localGen, plan } = {}) {
+export function updateUser(id, { disabled, dailyTokenLimit, dailyCostLimitUsd, lifetimeCostLimitUsd, role, moderationLevel, moderationLevelApi, localGen, plan, locale } = {}) {
   const sets = [];
   const args = [];
   if (disabled !== undefined) { sets.push('disabled = ?'); args.push(disabled ? 1 : 0); }
   if (moderationLevel !== undefined) { sets.push('moderation_level = ?'); args.push(moderationLevel ?? null); }
   if (moderationLevelApi !== undefined) { sets.push('moderation_level_api = ?'); args.push(moderationLevelApi ?? null); }
   if (localGen !== undefined) { sets.push('local_gen = ?'); args.push(localGen ? 1 : 0); }
+  if (locale !== undefined) {
+    if (locale !== null && !LOCALES.includes(locale)) throw new Error(`updateUser: locale 需为 ${LOCALES.join('/')} 或 null，收到 '${locale}'`);
+    sets.push('locale = ?'); args.push(locale ?? null);
+  }
   if (plan !== undefined) {
     if (!PLANS.includes(plan)) throw new Error(`updateUser: plan 需为 ${PLANS.join('/')}，收到 '${plan}'`);
     sets.push('plan = ?'); args.push(plan);

package/server/engine/agent/actor-trail.js

@@ -0,0 +1,110 @@
+/**
+ * engine/agent/actor-trail.js —— 「这次工具调用是谁发起的」（2026-08-26）
+ *
+ * ## 为什么需要这条路
+ *
+ * MCP 工具的 handler 拿不到调用者身份：`extra` 里只有 `_meta['claudecode/toolUseId']`、
+ * sessionId 那些，没有 agent_id / agent_type（2026-08-26 实测）。而 **hook 拿得到** ——
+ * `PreToolUse` 的 input 带 `agent_id` / `agent_type`，第二个参数就是 toolUseId。
+ *
+ * 所以：hook 在工具执行前把 (toolUseId → 谁) 记下来，MCP handler 用 extra 里的
+ * toolUseId 查回去。一条短命的旁路，不改 MCP 协议、不动工具签名。
+ *
+ * ## 归属的锚为什么必须是这条路，而不是角色文件
+ *
+ * 角色文件（`.claude/agents/rp-*.md`）**是模型可写的**，里面的展示名是**自称**：
+ * 一个角色可以把自己的 description 写成「RP 角色「用户」」，也可以顶替别的角色的名字。
+ * 拿它当归属 = 谁都能冒充谁。而 `agent_type` 是 harness 在派发那一刻亲眼所见并盖章的，
+ * 模型改不了。**权威是 slug，文件里的展示名只当展示层。**
+ *
+ * ## 生命周期
+ *
+ * 一次工具调用的寿命就是它的寿命。留一个上限防跑量（长会话里工具调用成千上万，
+ * 不清理就是内存漏），按插入序淘汰最旧的 —— 淘汰掉的最坏后果是那条板书落回
+ * 'agent' 署名，不影响正确性。
+ */
+
+const MAX = 500;
+const trail = new Map();   // toolUseId -> { agentId, agentType }
+
+/** hook 侧：工具执行前盖章 */
+export function noteToolCaller(toolUseId, { agentId = null, agentType = null } = {}) {
+  if (!toolUseId) return;
+  if (!agentId && !agentType) return;              // 主线程调用不必记，查不到就是主 agent
+  trail.set(toolUseId, { agentId, agentType });
+  if (trail.size > MAX) {
+    const oldest = trail.keys().next().value;
+    trail.delete(oldest);
+  }
+}
+
+/** 工具侧：查这次调用是谁 */
+export function callerOf(toolUseId) {
+  return (toolUseId && trail.get(toolUseId)) || null;
+}
+
+/**
+ * 演员位实例别名（2026-08-28 重构）：agentId → 实例名（rp-cheng-wan）。
+ *
+ * ## 为什么需要这张表
+ *
+ * 同型多实例之后，hook input 里的 `agent_type` 是演员位（rp-actor），**没有实例名
+ * 字段**（2026-08-28 探针：SubagentStart/PreToolUse/SubagentStop 三处 keys 全录，
+ * 只有 agent_id / agent_type）。而收件箱、名册、板书署名全按实例名走 —— 不桥接的话
+ * 所有角色的 byOf 塌成 'rp-actor'，收件箱共用一个坑。
+ *
+ * ## 学名字的两条路（都在 PostToolUse，见 hooks/slot-alias.js）
+ *
+ *   派发：Agent 的 tool_result 里有 `agentId: <id>`，tool_input.name 是实例名
+ *   唤醒：SendMessage 按名寄的 tool_result 里有 `resumedAgentId` + pin.name
+ *
+ * 表是会话内存态：服务器重启后角色本来就要重新派（名册同界），别名随新派发重新学。
+ * 上限防跑量同 trail —— 淘汰最旧的最坏后果是署名落回 'rp-actor'，不影响正确性。
+ */
+const agentNames = new Map();   // agentId -> 实例名
+export function noteAgentName(agentId, name) {
+  if (!agentId || !name) return;
+  agentNames.set(String(agentId), String(name));
+  if (agentNames.size > MAX) {
+    const oldest = agentNames.keys().next().value;
+    agentNames.delete(oldest);
+  }
+}
+export function agentNameOf(agentId) {
+  return (agentId && agentNames.get(String(agentId))) || null;
+}
+
+/**
+ * 派发闸认领了名字、还等着跟 agent_id 配对的队列（2026-08-29）。
+ *
+ * ## 为什么换掉旧桥
+ *
+ * 旧桥（hooks/slot-alias.js 的派发分支）从 **tool_result 的文本**里正则抠 `agentId:`。
+ * 2026-08-28 真会话实录：六条板书里五条署名落成演员位（`rp-narrator`），也就是那条
+ * 桥在生产上没接上 —— 而它一断，byOf 就塌回演员位，署名、去向判据、前端点名全认错人。
+ *
+ * 新桥不解析任何文本：派发闸认领名字时把名字排进队列，`SubagentStart` 那一刻
+ * harness 亲手给 `agent_id` + `agent_type`，两边一配就绑定。顺序天然对得上 ——
+ * 闸跑在工具执行前，子代理起飞在工具执行后，FIFO 就是派发顺序。
+ */
+const pendingRoleNames = [];
+const PENDING_MAX = 16;
+
+/** 派发闸侧：认领了这个名字，等它起飞 */
+export function notePendingRoleName(name) {
+  if (!name) return;
+  pendingRoleNames.push(String(name));
+  // 上限防跑量：派出去却从没起飞的名字（派发失败）会留在队里，超了就丢最旧的。
+  // 最坏后果是某个角色的署名落回演员位 —— 跟旧桥断掉时一样，不会更糟。
+  if (pendingRoleNames.length > PENDING_MAX) pendingRoleNames.shift();
+}
+
+/** SubagentStart 侧：取走队头的名字 */
+export function takePendingRoleName() {
+  return pendingRoleNames.shift() || null;
+}
+
+/** 测试用 */
+export function _resetActorTrail() {
+  trail.clear(); agentNames.clear(); pendingRoleNames.length = 0;
+}