mocode-ai 1.5.8 → 1.5.10

package/dist/session/compact.js

@@ -531,6 +531,10 @@ async function defaultSummarize(older, focus, signal, runtime = defaultCompactio
             '## Key Facts — only what later steps cannot work without: exact paths, symbols/API shapes, artifact IDs/hashes, open questions, failed approaches and errors to avoid repeating. User requests and constraints are pinned verbatim by the system from the raw user messages — do not duplicate them here; you own the technical facts.\n' +
             'What counts as important (keep): user requests and constraints; final state of each modified file; conclusions and results, not the steps that led there; decisions with reasons; precise references (paths, symbols, hashes, commands) that later steps must cite; failures and what was tried, so mistakes are not repeated.\n' +
             'What to drop: verbatim file contents and tool-output dumps, step-by-step recaps, exploration dead-ends that led nowhere, polite chatter, anything re-derivable by re-reading files.\n' +
+            // GUI 例外(§10.6):GUI 任务里动作序列本身就是状态——桌面上没有可回查的落点,压成散文
+            // 会导致'填过的字段被重填、点过的按钮被重点'。这条是依赖模型守规矩的兜底,硬保证是 L2
+            // 台账(gui-actions.log,每步写盘、跨 compact 存活)。
+            'GUI EXCEPTION to "step-by-step recaps": for computer/screen-control actions keep the SEQUENCE as an ordered list — one line per action: `N. <action> (<coordinates or target>) → <observed result, e.g. no visible change / re-captured diff X%>`. Never collapse it into prose ("clicked around the form") and never drop which attempts produced no visible change.\n' +
             'Rules: total ≤ 400 words. State conclusions and locations (path:line where useful), never paste content. ' +
             'The Key Facts section is carried forward verbatim into future summaries: write each fact as one self-contained line ' +
             '(no pronouns, no "as above", no cross-references), so it still reads correctly after later compactions. ' +

package/dist/session/gui-actions.js

@@ -0,0 +1,164 @@
+// session/gui-actions.ts - GUI 动作台账(L2)的存储与格式化。
+//
+// 与 notes.md 平级的**独立文件** `gui-actions.log`,每步一个 computer 动作追加一行,
+// 只保留最近 N 条。它回答的是"我做过什么 / 做到哪",与视觉窗口(最新几帧)互补:
+// 像素是空间轴(旧图快速贬值),台账是时间轴(第 3 步点过什么、哪次没生效,10 步后仍有价值)。
+//
+// 为什么是独立文件而不是写进 notes.md:notes.md 的 mtime 在本仓是**被监听的信号**
+// (tool-turn.ts 前后比对 getNotesMtime(),变了就清零 stepsSincePlanTouch),台账每步都写
+// 会让 plan nag 永不触发;且 note_append 走 ResourceLockManager 的 session-notepad 串行锁,
+// 每步争锁没必要。详见 design-notes/vision-window.md §10.3。
+//
+// 契约:
+//   - 写入失败**静默**:台账是可观测性,绝不能反过来影响 computer 动作的结果;
+//   - 顺序为追加语义,行首序号单调递增且在滚动裁剪后保持不变(§10.8 风险 3);
+//   - 语义纪律:记"意图 + 观察",不记"已达成"——"no visible change" 不升级成"成功"。
+import fs from 'node:fs';
+import path from 'node:path';
+import { getSandboxRoot } from '../sandbox/root.js';
+import { getCurrentSessionId } from './state.js';
+/** 台账文件名:与 notes.md 同目录(会话目录)。 */
+export const GUI_ACTIONS_FILENAME = 'gui-actions.log';
+/** 台账上界:只保留最近 N 条。24 ≈ 一个表单级任务的动作量,且与注入 token 预算匹配。 */
+export const GUI_ACTIONS_MAX_ENTRIES = 24;
+/** 一行台账的意图列宽(含对齐空格);超长不裁剪,仅退化为一个空格分隔。 */
+const INTENT_COLUMN = 26;
+/** 单条观察/错误文本上限:异常 output(栈、巨大 HTML)不该把一个 Monitor 动作撑成一屏。 */
+const DETAIL_LIMIT = 80;
+/** 注入时的段标题。 */
+const SECTION_HEADING = '## GUI actions (most recent last; from the live action ledger)';
+/**
+ * 注入时的纪律说明。§10.5 的硬约束:台账永远不能覆盖像素。
+ * 本实现不给条目加显式状态位(用户决策:沿用既有措辞),由这段说明统一给出冲突时的解法——
+ * 台账说"点过了"而屏幕没变化 → 以屏幕为准,该动作视为 attempted, unverified。
+ */
+const DISCIPLINE_LINE = 'These lines record intent + observation, never confirmed success: if the current screenshot disagrees with a line, the screenshot wins and that line counts as attempted but unverified.';
+/** 当前会话 gui-actions.log 的绝对路径;无会话时返 null。 */
+export function getGuiActionsFilePath(sessionId = getCurrentSessionId()) {
+    if (!sessionId)
+        return null;
+    const root = getSandboxRoot() ?? process.cwd();
+    return path.join(root, '.mocode', 'sessions', sessionId, GUI_ACTIONS_FILENAME);
+}
+function truncateDetail(raw) {
+    const flat = raw.replace(/\s+/g, ' ').trim();
+    return flat.length > DETAIL_LIMIT ? `${flat.slice(0, DETAIL_LIMIT)}…` : flat;
+}
+/** `left_click at (512, 300)` → `left_click (512, 300)`;`typed 18 characters` → `type 18 chars`。 */
+function normalizeIntent(summary) {
+    let text = summary.replace(/\s+/g, ' ').trim();
+    // 顺序敏感:先处理带自身句式的动作,最后才是泛化的 "<action> at (x, y)"。
+    text = text.replace(/^moved cursor to (\(.*\))$/, 'mouse_move $1');
+    text = text.replace(/^typed ([\d.]+) characters$/, 'type $1 chars');
+    text = text.replace(/^pressed key combo (".*")$/, 'key $1');
+    text = text.replace(/^dragged from (\([^)]*\)) to (\([^)]*\))$/, 'drag $1 -> $2');
+    text = text.replace(/^scrolled (\w+) by ([\d.]+) at (\(.*\))$/, 'scroll $1 $2 $3');
+    text = text.replace(/^waited ([\d.]+)ms$/, 'wait $1ms');
+    text = text.replace(/^cursor at physical \([^)]*\) = normalized (\(.*\))$/, 'cursor_position $1');
+    text = text.replace(/^(\w+) at (\(.*\))$/, '$1 $2');
+    return text;
+}
+/**
+ * 把 computer 工具的 output 解析成一条台账的"意图 + 观察"。
+ *
+ * 素材是 `src/tools/builtins/computer.ts` 已有的输出文本(existing per-action summary +
+ * 差分命中/回灌后缀),因此不需要新开采集通道。解析不出意图时返 null(调用方跳过)。
+ */
+export function parseComputerOutput(output) {
+    const text = (output ?? '').trim();
+    if (!text)
+        return null;
+    if (text.startsWith('computer action failed:')) {
+        return { intent: 'failed', observation: `error: ${truncateDetail(text.slice('computer action failed:'.length))}` };
+    }
+    if (text.startsWith('Zoomed into region ')) {
+        // zoom 会作废差分基准(computer.ts 置 lastFrame = null),因此必带新图、且只含局部区域。
+        return { intent: 'zoom', observation: 're-captured (zoomed region only)' };
+    }
+    if (text.startsWith('Screenshot captured (')) {
+        return { intent: 'screenshot', observation: 're-captured' };
+    }
+    const diffMatch = /\.\s*No visible change on screen \(frame diff ([\d.]+)%/.exec(text);
+    if (diffMatch) {
+        // 「no visible change」即"未达成"的现成措辞:保留原措辞,不升级成任何成功断言(§10.5)。
+        return {
+            intent: normalizeIntent(text.slice(0, diffMatch.index)),
+            observation: `no visible change, diff ${diffMatch[1]}%`,
+        };
+    }
+    const recapture = /\.\s*Screen re-captured \(/.exec(text);
+    if (recapture) {
+        return { intent: normalizeIntent(text.slice(0, recapture.index)), observation: 're-captured' };
+    }
+    return null;
+}
+/** 渲染一行台账;序号用于跨 compact / 跨裁剪保持"第几步"的可追溯性。 */
+export function formatGuiActionLine(seq, entry) {
+    const pad = ' '.repeat(Math.max(1, INTENT_COLUMN - entry.intent.length));
+    return `${seq}. ${entry.intent}${pad}→ ${entry.observation}`;
+}
+/** 读台账原文行(已含序号);文件缺失/不可读返空数组。 */
+export function readGuiActionEntries(sessionId = getCurrentSessionId()) {
+    const filePath = getGuiActionsFilePath(sessionId);
+    if (!filePath)
+        return [];
+    try {
+        return fs
+            .readFileSync(filePath, 'utf8')
+            .split('\n')
+            .map((line) => line.replace(/\r$/, ''))
+            .filter((line) => line.trim().length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/** 从既有行里取序号:滚动裁剪后序号必须继续递增,不能因为丢行而回退。 */
+function nextSequence(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const match = /^(\d+)\.\s/.exec(lines[i]);
+        if (match)
+            return Number(match[1]) + 1;
+    }
+    return 1;
+}
+/**
+ * 追加一条 computer 动作到台账。**失败静默**:写盘失败(只读目录 / ENOTDIR / 权限)不影响
+ * 动作本身,台账是可观测性而非功能依赖。
+ *
+ * @returns 写入后的行数(失败时为 0)。
+ */
+export function appendGuiAction(output, sessionId = getCurrentSessionId()) {
+    const entry = parseComputerOutput(output);
+    if (!entry)
+        return 0;
+    const filePath = getGuiActionsFilePath(sessionId);
+    if (!filePath)
+        return 0;
+    try {
+        const previous = readGuiActionEntries(sessionId);
+        const line = formatGuiActionLine(nextSequence(previous), entry);
+        const kept = [...previous, line].slice(-GUI_ACTIONS_MAX_ENTRIES);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, `${kept.join('\n')}\n`, 'utf8');
+        return kept.length;
+    }
+    catch {
+        // 台账不可写不得影响 computer 动作:这里是唯一允许吞掉错误的地方。
+        return 0;
+    }
+}
+/**
+ * 构造注入用的台账段(供 {@link buildSessionStateReminder} 拼进尾部 ephemeral system 消息)。
+ * 空台账返 ''(零开销,调用方此时不追加任何消息)。
+ */
+export function buildGuiActionsSection(sessionId = getCurrentSessionId()) {
+    const entries = readGuiActionEntries(sessionId);
+    if (entries.length === 0)
+        return '';
+    return [SECTION_HEADING, ...entries, DISCIPLINE_LINE].join('\n');
+}
+/** 供 /cu status 展示的条数:0 表示该会话还没有任何 computer 动作入账。 */
+export function countGuiActions(sessionId = getCurrentSessionId()) {
+    return readGuiActionEntries(sessionId).length;
+}

package/dist/tools/builtins/index.js

@@ -74,11 +74,14 @@ const CAPABILITIES = {
     computer: { effect: 'process', concurrency: 'serial', resources: () => ['desktop'], supportsAbort: true },
     // sub-agent 与主 agent 同权,直接写工作区(无 overlay)。编排器本身不持锁——锁由嵌套工具
     // 各自获取,否则子 agent 内的 run_command 会等父持有的 workspace 锁而自锁。
-    // 并发批排除见 tool-helpers.isResourceLockedCall:多个子 agent 逐个串行,不同时改工作区。
+    // parallelOrchestration:同一轮派发的多个子 agent 按 subAgentConcurrency 上限成批并行
+    // (调度见 tool-helpers.isParallelOrchestrationCall 与 run-coordinator 的编排批);
+    // isResourceLockedCall 仍显式排除 sub-agent,使其不混入 file-mutation 批。
     'sub-agent': {
         effect: 'write',
         concurrency: 'resource-locked',
         delegatesResourceLocks: true,
+        parallelOrchestration: true,
         supportsAbort: true,
     },
 };

package/dist/tools/builtins/read-file.js

@@ -12,6 +12,9 @@ export const readFileTool = {
     description: 'Read file content with line numbers. Read before editing.\n' +
         'For files >500 lines: grep first to locate regions, then call read_file multiple times ' +
         'with offset+limit (e.g. offset=350, limit=120). Do NOT read an entire large file in one call.\n' +
+        'When you need several regions of the SAME file, issue those read_file calls together in one ' +
+        'response (they run concurrently) instead of paging through it one page after another — ' +
+        'avoid sequential offset+=limit walks of the same file.\n' +
         'For files ≤500 lines you may read the whole file in one call. Independent region reads ' +
         'may be issued in the same response — they run concurrently, saving a round-trip each.\n' +
         'For architecture or call-chain questions, prefer loading the `codegraph` skill (use_skill) over reading files one at a time.',

package/dist/tools/constants.js

@@ -63,7 +63,17 @@ export const MAX_GRAPH_ENTITIES = 500;
 export const MAX_GRAPH_EDGES = 2000;
 // .codegraph:codegraph 索引目录(codegraph.db 是 SQLite 二进制 + daemon.log),
 // grep/glob 扫它无意义且会产出数 KB 的超长「行」,污染 TUI 展开渲染。
-export const IGNORE = ['**/node_modules/**', '**/.git/**', '**/.codegraph/**'];
+// 构建产物目录同理:rust/(cargo target,数千个 .o/.rmeta 二进制)、dist/ 与 dist-tests/
+// (tsc 产物,与 src 的 .ts 一一对应的 .js,扫它们只会重复命中并拖慢全库 grep——
+// 实测无 glob 限定的 grep 扫全库耗时 205s,其中大半耗在这类目录)。
+export const IGNORE = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/.codegraph/**',
+    '**/rust/**',
+    '**/dist/**',
+    '**/dist-tests/**',
+];
 // ── legacy profile fallback（官方 TUI/stdio 已由 ToolPolicy 控制）────────────────
 // 保留导出名以兼容未传 ToolPolicy 的嵌入调用与旧测试。
 export const FRONTEND_TOOLS = new Set(TOOL_GROUPS.frontend);

package/dist/tools/jev-client.js

@@ -0,0 +1,192 @@
+/**
+ * Jev / TypeSafe systemone 协议客户端(工具预路由的第二后端)。
+ *
+ * 为什么是独立文件而不是塞进 src/llm/index.ts:
+ * Jev 不是 OpenAI 兼容的 /chat/completions 模型——它一次问一组「是/否」问题、每组独立
+ * 返回一个 0~1 的概率(noul 原语),没有 messages/tool_calls 概念。硬套 chat() 的
+ * ChatTransport 契约会污染主链路。故单独一个极薄的 HTTP 客户端,只做:
+ *   构造 body → POST → 解析 answers[<group>].noul → 归一化成 {组名: 概率}。
+ *
+ * 失败语义:除用户取消(AbortError)外**永不抛错**,一律返回 {ok:false,error}。
+ * router 侧据此走 fallbackDecision(沿用上一 turn 簇)。503/529/429 等瞬时错误内部退避重试。
+ *
+ * 键名陷阱:API 的 answers 键用下划线(browser_debug),而 mocode 的簇名用连字符
+ * (browser-debug)。本文件用 underscoreKey() 单点转换,调用方只见连字符簇名。
+ */
+/** 默认官方端点;本地部署(如 0xBakeer/arbiter 兼容层)可经配置覆盖 baseUrl。 */
+export const DEFAULT_JEV_BASE_URL = 'https://api.typesafe.ai';
+const REQUEST_TIMEOUT_MS = 60_000;
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504, 529]);
+const MAX_ATTEMPTS = 4;
+let fetchImplOverride = null;
+/** 仅供单测注入;生产路径使用 Node 18+ 全局 fetch。 */
+export function __setJevFetchImpl(impl) {
+    fetchImplOverride = impl;
+}
+/** 簇名 → API 键:连字符转下划线(browser-debug → browser_debug)。 */
+export function underscoreKey(group) {
+    return group.replace(/-/g, '_');
+}
+/** 把外部 signal 与超时合并成一个 signal;返回的 cleanup 必须调用。 */
+function withTimeout(signal, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('jev request timeout')), timeoutMs);
+    const onAbort = () => controller.abort(signal?.reason);
+    if (signal) {
+        if (signal.aborted)
+            controller.abort(signal.reason);
+        else
+            signal.addEventListener('abort', onAbort, { once: true });
+    }
+    const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener('abort', onAbort);
+    };
+    return { signal: controller.signal, cleanup };
+}
+/**
+ * 仅当**外部** signal 已 abort 才算「用户取消」。
+ *
+ * 不能靠 error.name === 'AbortError' 判断:内部超时也是用 AbortController 触发的,
+ * 同样抛出 AbortError;而 runtime 每个 turn 都会传外部 signal,若按错误名判断,一次
+ * 慢响应(超时)就会被误当用户取消而上抛,直接中止用户整轮——这与「失败降级」契约相反。
+ * 故只认外部 signal 自身的 aborted 标志:超时走普通失败回报(可重试/降级)。
+ */
+function isExternalAbort(signal) {
+    return signal?.aborted === true;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function finiteProbability(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return Math.max(0, Math.min(1, value));
+    return undefined;
+}
+/**
+ * 问一次 Jev。返回各组概率;失败返回 {ok:false}。
+ * 用户取消(signal.aborted)会抛出 AbortError —— 与 chat() 的取消语义一致,由 router 决定
+ * 是中止本轮还是降级。
+ */
+export async function askJev(request) {
+    const startedAt = Date.now();
+    const base = (request.baseUrl ?? DEFAULT_JEV_BASE_URL).replace(/\/+$/, '');
+    const endpoint = `${base}/v1/systemone`;
+    const apiKey = request.apiKey ?? '';
+    const questions = {};
+    for (const [group, question] of Object.entries(request.questions)) {
+        questions[underscoreKey(group)] = question;
+    }
+    const body = {
+        model: request.model || 'jev-latest',
+        state: {
+            mode: request.mode ?? 'AUTO',
+            previous_groups: [...(request.previousGroups ?? [])],
+            task: request.task,
+        },
+        questions,
+    };
+    const maxAttempts = Math.max(1, request.maxAttempts ?? MAX_ATTEMPTS);
+    let lastError = 'unknown error';
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const { signal, cleanup } = withTimeout(request.signal, request.timeoutMs ?? REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            const impl = fetchImplOverride ?? fetch;
+            response = await impl(endpoint, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+        }
+        catch (error) {
+            cleanup();
+            // 只有外部 signal 自身已 abort(用户取消)才上抛;内部超时走下方重试/降级。
+            if (isExternalAbort(request.signal))
+                throw error;
+            lastError = `request failed: ${error instanceof Error ? error.message : String(error)}`;
+            if (attempt < maxAttempts) {
+                await sleep(Math.min(1000 * 2 ** (attempt - 1), 8000));
+                continue;
+            }
+            return { ok: false, error: lastError, latencyMs: Date.now() - startedAt };
+        }
+        if (!response.ok) {
+            // 非 JSON 错误页只保留前缀,避免把代理 HTML 大段带进日志。
+            let detail = '';
+            try {
+                detail = (await response.text()).slice(0, 180);
+            }
+            catch {
+                detail = '';
+            }
+            cleanup();
+            lastError = `HTTP ${response.status}${detail ? ` ${detail}` : ''}`;
+            if (RETRYABLE_STATUS.has(response.status) && attempt < maxAttempts) {
+                await sleep(Math.min(1000 * 2 ** (attempt - 1), 8000));
+                continue;
+            }
+            return { ok: false, error: lastError, latencyMs: Date.now() - startedAt };
+        }
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch (error) {
+            cleanup();
+            lastError = `invalid JSON response: ${error instanceof Error ? error.message : String(error)}`;
+            return { ok: false, error: lastError, latencyMs: Date.now() - startedAt };
+        }
+        cleanup();
+        const record = payload && typeof payload === 'object' ? payload : {};
+        const rawAnswers = record.answers && typeof record.answers === 'object' ? record.answers : {};
+        const probabilities = {};
+        let inheritPrevious;
+        for (const group of Object.keys(request.questions)) {
+            const answer = rawAnswers[underscoreKey(group)];
+            if (!answer || typeof answer !== 'object')
+                continue;
+            const probability = finiteProbability(answer.noul);
+            if (probability !== undefined)
+                probabilities[group] = probability;
+        }
+        const inheritAnswer = rawAnswers.inherit_previous;
+        if (inheritAnswer && typeof inheritAnswer === 'object') {
+            inheritPrevious = finiteProbability(inheritAnswer.noul);
+        }
+        const usage = record.usage && typeof record.usage === 'object' ? record.usage : {};
+        const inputTokens = typeof usage.input_tokens === 'number' && Number.isFinite(usage.input_tokens)
+            ? usage.input_tokens
+            : undefined;
+        return {
+            ok: true,
+            probabilities,
+            inheritPrevious,
+            latencyMs: Date.now() - startedAt,
+            model: typeof record.model === 'string' ? record.model : undefined,
+            inputTokens,
+        };
+    }
+    return { ok: false, error: lastError, latencyMs: Date.now() - startedAt };
+}
+/**
+ * 探测端点连通性(供 /router test 使用):用最小问题集问一次,返回是否可用 + 延迟。
+ * 永不抛错(取消除外)。
+ */
+export async function probeJev(options) {
+    const result = await askJev({
+        task: 'connectivity probe',
+        questions: { probe: { type: 'noul', instructions: 'Is this a connectivity probe?' } },
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
+        model: options.model,
+        signal: options.signal,
+        timeoutMs: 20_000,
+        maxAttempts: 2,
+    });
+    if (result.ok)
+        return { ok: true, latencyMs: result.latencyMs, model: result.model };
+    return { ok: false, latencyMs: result.latencyMs, error: result.error };
+}

package/dist/tools/router.js

@@ -1,6 +1,8 @@
 import { chat } from '../llm/index.js';
 import { COMMON_TOOL_NAMES, DEFAULT_ROUTE_GROUPS, TOOL_ROUTE_GROUPS, isToolRouteGroupName, } from '../config/profiles.js';
 import { getRoutableToolRouteGroups, toolRouteCatalog } from './policy.js';
+import { getRouterMode, getJevRouterConfig, isJevRouterConfigured } from '../config/index.js';
+import { askJev } from './jev-client.js';
 const ROUTER_TOOL_NAME = 'select_tool_groups';
 const MAX_ROUTER_INPUT_CHARS = 12_000;
 function routeSelectorTool(groups) {
@@ -82,8 +84,11 @@ function parseDecision(raw, available, previousGroups, startedAt) {
     };
 }
 /**
- * 每个真实用户 turn 强制执行一次无副作用 LLM 预路由。失败时沿用上一 turn 的簇；主 Agent
- * 仍可通过 add_tool_groups 自救，但绝不因路由失败直接暴露 full 工具集。
+ * 每个真实用户 turn 强制执行一次无副作用预路由。后端由 /router 选择:
+ *   - `llm`(默认):与主 Agent 同一后端,直出一个簇集合,无可调旋钮。
+ *   - `jev`:TypeSafe systemone,每组独立出 0~1 概率,按阈值出簇(阈值可调是选它的核心理由)。
+ * 两条路径失败都沿用上一 turn 的簇;主 Agent 仍可通过 add_tool_groups 自救,
+ * 但绝不因路由失败直接暴露 full 工具集。
  */
 export async function routeToolGroups(request) {
     const startedAt = Date.now();
@@ -95,6 +100,84 @@ export async function routeToolGroups(request) {
     if (availableGroups.length === 0) {
         return fallbackDecision(startedAt, [], `No routable tool groups are currently available; using common tools plus always-on ${DEFAULT_ROUTE_GROUPS.join(', ')}.`);
     }
+    if (getRouterMode() === 'jev') {
+        return routeWithJev(request, availableGroups, available, previousGroups, startedAt);
+    }
+    return routeWithLlm(request, availableGroups, available, previousGroups, startedAt);
+}
+/**
+ * Jev(TypeSafe systemone)路由:每组独立问一个 noul 问题,拿到 0~1 概率后按阈值出簇。
+ *
+ * 与 LLM 路径的差别:LLM 直出一个集合、没有可调旋钮;Jev 出概率,阈值才是可调旋钮——
+ * 这正是值得接它的理由(可按 假阴:假阳 的代价比调 operating point)。
+ *
+ * 问题正文复用 TOOL_ROUTE_GROUPS[g].description(与 LLM 路径的 catalog 同一来源),
+ * 避免「组语义」在多处各写一份而漂移。
+ */
+async function routeWithJev(request, availableGroups, available, previousGroups, startedAt) {
+    if (!isJevRouterConfigured()) {
+        return fallbackDecision(startedAt, previousGroups, 'Jev router selected but MOCODE_ROUTER_JEV_API_KEY is unset; reused previous groups. Run /router key <key>.');
+    }
+    const jevConfig = getJevRouterConfig();
+    const questions = {};
+    for (const group of availableGroups) {
+        questions[group] = {
+            type: 'noul',
+            instructions: `Does the next agent turn need this capability: ${TOOL_ROUTE_GROUPS[group].description}`,
+        };
+    }
+    let result;
+    try {
+        result = await askJev({
+            task: request.input.slice(0, MAX_ROUTER_INPUT_CHARS),
+            questions,
+            mode: request.planMode ? 'PLAN' : 'AUTO',
+            previousGroups,
+            baseUrl: jevConfig.baseUrl,
+            apiKey: jevConfig.apiKey,
+            model: jevConfig.model,
+            signal: request.signal,
+        });
+    }
+    catch (error) {
+        // 只有用户取消会抛(见 jev-client):与 LLM 路径一致地继续上抛,由 runtime 撤回本轮。
+        if (request.signal?.aborted || (error instanceof Error && error.name === 'AbortError'))
+            throw error;
+        return fallbackDecision(startedAt, previousGroups, `Jev router failed (${error instanceof Error ? error.message : String(error)}); reused previous groups.`);
+    }
+    if (!result.ok) {
+        return fallbackDecision(startedAt, previousGroups, `Jev router failed (${result.error}); reused previous groups.`);
+    }
+    const selected = [];
+    for (const group of availableGroups) {
+        const probability = result.probabilities[group];
+        if (probability === undefined)
+            continue;
+        // mcp 用更高门槛:实测它是系统性假阳性磁铁(对无关任务也给 0.5–0.7)。
+        const threshold = group === 'mcp' ? jevConfig.confidenceMinMcp : jevConfig.confidenceMin;
+        if (probability >= threshold)
+            selected.push(group);
+    }
+    const inheritPrevious = (result.inheritPrevious ?? 0) >= 0.5;
+    const merged = new Set(inheritPrevious ? previousGroups : []);
+    for (const group of selected)
+        merged.add(group);
+    // confidence 取「已选簇里最小的那个概率」:最弱一环决定整体可信度,且随阈值单调。
+    const selectedProbabilities = selected
+        .map((group) => result.probabilities[group])
+        .filter((value) => value !== undefined);
+    const confidence = selectedProbabilities.length ? Math.min(...selectedProbabilities) : 0;
+    return {
+        groups: [...merged].filter((group) => available.has(group)),
+        inheritPrevious,
+        confidence,
+        reason: `Jev(${result.model ?? jevConfig.model}) selected ${merged.size ? [...merged].join(', ') : 'no extra groups'} at thresholds ${jevConfig.confidenceMin}/${jevConfig.confidenceMinMcp}.`,
+        latencyMs: Date.now() - startedAt,
+        fallback: false,
+    };
+}
+/** LLM 路由(默认路径):一次 select_tool_groups 工具调用,直出簇集合。 */
+async function routeWithLlm(request, availableGroups, available, previousGroups, startedAt) {
     // 路由规则与示例、profiles.ts 的 TOOL_ROUTE_GROUPS descriptions 是三源:逐组启发式和
     // Examples 是对 descriptions 的强化(对弱模型有真实价值),但组定义变更时三处需同步维护。
     const system = `You are mocode's capability router. You do not solve the task and you cannot execute tools.

package/dist/ui/layout-internal/content-write.js

@@ -328,6 +328,7 @@ export function clearContent() {
     // 欢迎引导块随 buffer 一起清掉(/clear / /resume 等路径),状态复位后可由 repl 重新写入。
     state.welcomeStart = -1;
     state.welcomeRows = 0;
+    state.welcomeSource = [];
     // 清内容区必须同时作废旧菜单擦除坐标:picker(/resume /rollback /theme)把菜单画在内容区底部,
     // 菜单行号缓存在 lastMenuStartRow/lastMenuRows;若不清零,后续 paintInput 会按旧坐标“擦菜单”,
     // 把刚 renderHistory/contentWrite 写好的内容(如“已续接会话”提示)清掉,导致用户要滚动一下才刷新。
@@ -364,16 +365,72 @@ export function rewindContent(rowsToRewind) {
 // ── 欢迎引导块(新会话开场)──
 // 开场写在内容区(banner 之下),教用户怎么开始;首次提交任何输入(消息或斜杠命令)前
 // 由 dismissWelcomeBlock 整块从 buffer 撤掉——「一打开就能看见,开始干活就消失」。
-/** 写欢迎引导块(每行自洽带色、行宽须 ≤ cols,contentWrite 状态机兜底折行);已在屏上则跳过。 */
+//
+// 居中在本层现算:调用方(runtime.welcomeLines)只产出**逻辑行**(带色、不带缩进),
+// 这里按写入当时的列宽补左缩进,并把逻辑行源记入 state.welcomeSource——终端 resize 后
+// reflowWelcomeBlockForResize 按新列宽重新居中/折行重排整块。否则块停留在旧宽度:
+// 缩窄后被 viewport 截断成「…」、放宽后仍偏在旧位置(「提示不随窗口变化」bug)。
+/** 欢迎块逻辑行 → 待写物理行:按可见宽度(剥 ANSI、CJK 计 2)整行居中,余数归右。
+ *  空行原样;可见宽度 ≥ cols 的行不缩进,超宽部分由 contentWrite 状态机折行兜底。 */
+export function renderWelcomeRows(lines, cols) {
+    return lines.map((line) => {
+        const w = ansiDisplayWidth(line);
+        if (w <= 0 || w >= cols)
+            return line;
+        return ' '.repeat(Math.floor((cols - w) / 2)) + line;
+    });
+}
+/** 写欢迎引导块(逻辑行经 renderWelcomeRows 居中后写入,contentWrite 兜底折行);已在屏上则跳过。 */
 export function writeWelcomeBlock(lines) {
     if (!state.active || !ui.isTTY || lines.length === 0)
         return;
     if (state.welcomeRows > 0)
         return; // 已在屏上,不重复写
+    state.welcomeSource = [...lines];
     state.welcomeStart = content.committedRows();
-    contentWrite(lines.join('\n') + '\n');
+    contentWrite(renderWelcomeRows(lines, getGeo().cols).join('\n') + '\n');
     state.welcomeRows = content.committedRows() - state.welcomeStart;
 }
+/**
+ * resize(列宽变化)后按新列宽重排欢迎引导块,返回 ReflowChange 供调用方统一迁移
+ * 选区 / batch / viewport 锚点;不可安全重排时返回 null,保持旧行不动。
+ *
+ * 前提:块可见期间它恒为缓冲尾(写入后、首次输入撤块前没有任何内容写在它后面;
+ * /clear 重写时同样在尾部)。据此用「删尾块 → 续写位回到块首 → 按新列宽重写」即可
+ * 原地重排,行数变化由 committedRows 差值重新记账。guard 拒绝例外场景:
+ *  - 滚动回看中 / md 流式段活跃:welcome 与二者不应共存(块在首次输入前就撤掉),
+ *    真发生时不动块,退回旧行为;
+ *  - 块后已有内容(不变式被破坏):重写会盖到后续内容,放弃。
+ */
+function reflowWelcomeBlockForResize(cols) {
+    const start = state.welcomeStart;
+    const n = state.welcomeRows;
+    const source = state.welcomeSource;
+    if (!source || source.length === 0 || n <= 0 || start < 0)
+        return null;
+    if (state.scrollOffset > 0 || state.mdActive)
+        return null;
+    if (start + n !== content.committedRows())
+        return null;
+    const oldLines = [];
+    for (let i = start; i < start + n; i++)
+        oldLines.push(content.lineAt(i) ?? '');
+    // 用 content 层原语(而非 layout 包装 contentDeleteFrom):batch 索引平移由调用方对返回的
+    // ReflowChange 统一做 shiftBatchesForReflow,这里再 shiftBatchesAfter 会双重平移。
+    // segmentStartRow / scrollOffset 已被 guard 排除(mdActive / scrolled 均返回 null),无需维护。
+    content.deleteFrom(start, n);
+    // 块是缓冲尾 → 删后续写位 = 块首。显式重锚(contentWrite 入口的归一化在块曾溢出屏、
+    // contentRow 已被钳到 contentBottom 时算不准),contentWrite 入口会再归一化一次,两处一致。
+    const g = getGeo();
+    state.contentRow = Math.min(start + 1, g.contentBottom);
+    state.contentCol = 1;
+    contentWrite(renderWelcomeRows(source, cols).join('\n') + '\n');
+    state.welcomeRows = content.committedRows() - start;
+    const newLines = [];
+    for (let i = start; i < start + state.welcomeRows; i++)
+        newLines.push(content.lineAt(i) ?? '');
+    return { start, oldCount: n, newCount: state.welcomeRows, delta: state.welcomeRows - n, oldLines, newLines };
+}
 /** 撤掉欢迎引导块:删 buffer 区间(若已被外部清空/裁掉则只复位状态)+ 续写位前移 + 钳位重画。 */
 export function dismissWelcomeBlock() {
     if (state.welcomeRows <= 0)
@@ -382,6 +439,7 @@ export function dismissWelcomeBlock() {
     const n = state.welcomeRows;
     state.welcomeRows = 0;
     state.welcomeStart = -1;
+    state.welcomeSource = [];
     if (start < 0 || start >= content.committedRows())
         return; // 块已被 clear/trim,无需删
     content.deleteFrom(start, n);
@@ -545,13 +603,21 @@ function remapLineForReflow(line, change) {
     const relative = (line - change.start) / Math.max(1, change.oldCount - 1);
     return change.start + Math.round(relative * Math.max(0, change.newCount - 1));
 }
-/** 终端尺寸变化后更新正文布局。列宽变化时重排 markdown；仅高度变化时只重算屏幕锚点。 */
+/** 终端尺寸变化后更新正文布局。列宽变化时先重排欢迎块、再重排 markdown 段;仅高度变化时只重算屏幕锚点。 */
 export function reflowContentForResize(cols, colsChanged) {
     const oldTotal = content.totalRows();
     const oldViewportStart = viewportAbsStart();
     const oldViewportEnd = Math.max(oldViewportStart, oldTotal - state.scrollOffset - 1);
     let mappedViewportEnd = oldViewportEnd;
-    const changes = colsChanged ? content.reflowMarkdown(cols, renderMarkdown) : [];
+    const changes = [];
+    if (colsChanged) {
+        // 欢迎块先于 markdown 段重排:它可见期间恒在缓冲头部区(banner 之后、任何 md 段之前),
+        // 其行数变化会平移后续段;先重排它,reflowMarkdown 报告的 start 才与它在同一坐标系。
+        const welcomeChange = reflowWelcomeBlockForResize(cols);
+        if (welcomeChange)
+            changes.push(welcomeChange);
+        changes.push(...content.reflowMarkdown(cols, renderMarkdown));
+    }
     for (const change of changes) {
         shiftBatchesForReflow(change.start, change.oldCount, change.newCount);
         mappedViewportEnd = remapLineForReflow(mappedViewportEnd, change);

package/dist/ui/layout-internal/state.js

@@ -33,6 +33,9 @@ export const state = {
     bannerH: 0,
     welcomeStart: -1, // 块起点(content.committedRows 口径的绝对行索引)
     welcomeRows: 0, // 块行数(0 = 屏上无欢迎块)
+    /** 欢迎块逻辑行源(带色、不带居中缩进)。writeWelcomeBlock 记录,列宽变化后由
+     *  reflowWelcomeBlockForResize 按新列宽重新居中/折行重排;clear / dismiss 时清空。 */
+    welcomeSource: [],
     // ── 滚动与流式暂停(回看冻结 / 打字期停物理写) ──
     scrollOffset: 0, // 滚动回看距尾行数(0=尾,跟随新内容);>0 时 viewport 显历史、状态行显滚动指示
     scrollLockUntil: 0, // 发消息轮首滚动锁(绝对时间戳 ms,0=未锁):吸收 stdin 残留滚轮事件,防 resetScroll 回尾后被重新滚上去

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 25 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {