mocode-ai 1.2.6 → 1.2.8

package/dist/session/compact.js

@@ -1,6 +1,6 @@
 import { chat, chatTools, correctTokenEstimate, estimatePromptTokens, estimateTokens, } from '../llm/index.js';
 import { config } from '../config/index.js';
-import { MAX_HISTORY_RESULT, MAX_MEMORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RESULT } from '../tools/constants.js';
+import { MAX_HISTORY_RESULT, MAX_MEMORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RESULT, SUMMARY_MSG_MAX_CHARS, SUMMARY_OUTPUT_MAX_CHARS, SUMMARY_TRANSCRIPT_WINDOW_RATIO, } from '../tools/constants.js';
 import { ui } from '../ui/theme.js';
 import { Spinner } from '../ui/spinner.js';
 import * as layout from '../ui/layout.js';
@@ -221,45 +221,105 @@ function microcompactGroup(g) {
     return done;
 }
 // ── 默认摘要器:复用 chat(),空 handlers 不打印 ──────────────────────────
-async function defaultSummarize(older, focus) {
-    // 摘要前剥离多模态 user 消息里的图片(base64 会撑爆摘要 prompt;image 对摘要无信息量)。
-    const stripped = older.map(stripImagesForSummary);
-    let transcript = stripped
+/** 单条消息封顶:中间段省略、保头 + 尾(头有路径/意图,尾有结论/报错),总长 ≤ max。 */
+function capMessageText(text, max) {
+    if (text.length <= max)
+        return text;
+    const removed = text.length - max;
+    const marker = `\n…[中间 ${removed} 字符已省略]…\n`;
+    let remain = max - marker.length;
+    if (remain <= 0)
+        return text.slice(0, Math.max(0, max)) + marker;
+    const head = Math.ceil(remain * 0.6);
+    return text.slice(0, head) + marker + text.slice(text.length - (remain - head));
+}
+/** tool_call 参数封顶:只保头(路径/目标等关键信息在开头,长正文对摘要无信息量)。 */
+function capArgsHead(args, max) {
+    if (args.length <= max)
+        return args;
+    return args.slice(0, max) + ` …[另有 ${args.length - max} 字符已省略]`;
+}
+/** 摘要输出硬上限:按最后换行处裁断(不留半句),防模型不听话产出巨长摘要撑大 history。 */
+function capSummaryOutput(summary) {
+    if (summary.length <= SUMMARY_OUTPUT_MAX_CHARS)
+        return summary;
+    const cut = summary.lastIndexOf('\n', SUMMARY_OUTPUT_MAX_CHARS);
+    const at = cut > SUMMARY_OUTPUT_MAX_CHARS * 0.5 ? cut : SUMMARY_OUTPUT_MAX_CHARS;
+    return summary.slice(0, at) + '\n[摘要输出超长,已截断]';
+}
+/** 按封顶配额拼转录。scale ∈ (0,1] 等比缩小各角色配额(总预算不足时用)。 */
+function buildTranscript(stripped, scale) {
+    const caps = SUMMARY_MSG_MAX_CHARS;
+    const capFor = (role) => Math.max(200, Math.floor(scale *
+        (role === 'user'
+            ? caps.user
+            : role === 'assistant'
+                ? caps.assistant
+                : role === 'tool'
+                    ? caps.tool
+                    : caps.other)));
+    return stripped
         .map((m) => {
-        const role = m.role;
-        let line = `${role}: ${toText(m.content)}`;
+        const cap = capFor(m.role);
+        let line = `${m.role}: ${capMessageText(toText(m.content), cap)}`;
         const tcs = m.tool_calls;
         if (tcs) {
             for (const tc of tcs) {
-                line += `\n  [tool_call ${tc?.function?.name}] ${tc?.function?.arguments ?? ''}`;
+                const args = tc?.function?.arguments ?? '';
+                line += `\n  [tool_call ${tc?.function?.name}] ${capArgsHead(args, Math.max(200, Math.floor(scale * caps.tool)))}`;
             }
         }
         return line;
     })
         .join('\n');
-    // 防摘要提示本身溢出:超 60% 窗口就先中截到 50%
-    if (estimateTokens(transcript) >
-        Math.floor(config.contextWindowTokens * 0.6)) {
-        transcript = truncateMid(transcript, Math.floor(config.contextWindowTokens * 0.5));
+}
+async function defaultSummarize(older, focus) {
+    // 摘要前剥离多模态 user 消息里的图片(base64 会撑爆摘要 prompt;image 对摘要无信息量)。
+    const stripped = older.map(stripImagesForSummary);
+    // 触发压缩时旧区约占窗口 50-60%,摘要器共享同一窗口——逐条封顶后旧区原文即可装入,
+    // 不需要"先压一遍再摘要"。封顶策略:先按满额封顶;总量仍超窗口 55% 预算时等比缩小
+    // 配额重拼(优先保条数/每轮都有代表,其次保单条长度);再超才整段中截兜底(罕见)。
+    let transcript = buildTranscript(stripped, 1);
+    const tokenBudget = Math.floor(config.contextWindowTokens * SUMMARY_TRANSCRIPT_WINDOW_RATIO);
+    let tokens = estimateTokens(transcript);
+    if (tokens > tokenBudget) {
+        transcript = buildTranscript(stripped, tokenBudget / tokens);
+        tokens = estimateTokens(transcript);
+        if (tokens > Math.floor(config.contextWindowTokens * 0.6)) {
+            transcript = truncateMid(transcript, Math.floor(config.contextWindowTokens * 0.5));
+        }
     }
     const sysMsg = {
         role: 'system',
-        content: 'You are a session summarizer. Output only the summary body, max 300 words, preserving: the user\'s core request; files read/written/modified and key changes; source artifact IDs/hashes; key commands run and their result highlights; decisions made; current task progress and next step; open questions. Do not recap every detail.',
+        content: 'You are an aggressive session compressor writing a handoff note for an agent that lost its context. ' +
+            'The agent will continue the task with ONLY your summary plus a few most-recent messages, so your summary is the sole memory of everything older.\n' +
+            'Output ONLY the summary body in this exact structure (omit empty sections):\n' +
+            '## Objective — the user\'s core request(s); cover EVERY distinct user request in the transcript, in order, noting which are completed vs pending.\n' +
+            '## Completed — what is already done: files created/modified (exact paths), key change per file, commands run and their outcomes (pass/fail, key numbers), decisions made and why.\n' +
+            '## In Progress — what is being worked on right now and exactly where it stopped (e.g. "edit applied to foo.ts, test not yet run").\n' +
+            '## Next Steps — the concrete next actions in order.\n' +
+            '## Key Facts — only what later steps cannot work without: exact paths, symbols/API shapes, artifact IDs/hashes, constraints, open questions, failed approaches and errors to avoid repeating.\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' +
+            'Rules: total ≤ 400 words. State conclusions and locations (path:line where useful), never paste content. ' +
+            'Never invent facts, paths, or results that are not in the transcript; if unsure whether something happened, omit it.',
     };
     const userMsg = {
         role: 'user',
         content: focus
-            ? `请将以下会话历史压缩成摘要,重点保留与「${focus}」相关的事实/决策/文件改动:\n\n${transcript}\n\n摘要:`
-            : `请将以下会话历史压缩成摘要:\n\n${transcript}\n\n摘要:`,
+            ? `请将以下会话历史压缩成交接摘要,重点保留与「${focus}」相关的事实/决策/文件改动:\n\n${transcript}\n\n摘要:`
+            : `请将以下会话历史压缩成交接摘要:\n\n${transcript}\n\n摘要:`,
     };
     const spinner = new Spinner((msg, frame) => layout.setStatus(msg, frame ?? undefined));
     spinner.start('压缩中');
     try {
-        const r = await chat([sysMsg, userMsg], {}); // 空 handlers:不打印、不外显流式
+        // 空 handlers:不打印、不外显流式;tools=[] 不带工具表——摘要纯文本任务,
+        // 全量工具 schema 白占几千 token 窗口,还诱导幻觉工具调用。
+        const r = await chat([sysMsg, userMsg], {}, undefined, []);
         // 推理模型可能只返 reasoning_content(content 为 null),或幻觉出 tool_calls → 视为失败
         if (r.toolCalls.length > 0 || !r.content)
             return null;
-        return r.content;
+        return capSummaryOutput(r.content);
     }
     finally {
         spinner.stop();
@@ -277,7 +337,12 @@ export async function compactHistory(history, opts) {
     state.lastEstimate = estimateBefore;
     const groups = groupFromEnd(history);
     // 保近期:按策略中的 token 比例累积(至少保 1 组),永不劈开 group。
-    const keepBudget = Math.floor(opts.window * DEFAULT_BUDGET_POLICY.compactKeepRatio);
+    // force(手动 /compact 默认、硬闸触发)用更激进的保留比例;再加绝对上限,
+    // 防大窗口(如 256k)下保留区按比例仍过大——压缩目标 = 摘要 + 最小续工上下文。
+    const keepRatio = opts.force
+        ? DEFAULT_BUDGET_POLICY.compactForceKeepRatio
+        : DEFAULT_BUDGET_POLICY.compactKeepRatio;
+    const keepBudget = Math.min(Math.floor(opts.window * keepRatio), DEFAULT_BUDGET_POLICY.compactKeepMaxTokens);
     const kept = [];
     let keptTokens = 0;
     for (let k = groups.length - 1; k >= 0; k--) {
@@ -292,10 +357,22 @@ export async function compactHistory(history, opts) {
     let oldGroups = groups.slice(0, groups.length - kept.length);
     // force(硬闸/手动强压):保护区不豁免——常规切分无旧区时只保最后一组,
     // 其余全部进可压区(首轮/当前轮也一样)。仍按 group 边界切,不破坏 tool_call 配对。
+    // **必须保留最早 user 所在 group**:LLM API(OpenAI / Anthropic)要求 messages 至少
+    //  含一条非空 user 消息,否则 400。force 旧实现把所有 user 丢进摘要 → 重建后 history
+    //  无 user → 下一轮 chat() 被后端拒绝。保最早 user(而非最后一个)因为它是最原始的
+    //  请求上下文,摘要器已覆盖后续交互。
     if (oldGroups.length === 0 && opts.force && groups.length >= 2) {
         kept.length = 0;
-        kept.push(groups[groups.length - 1]);
-        oldGroups = groups.slice(0, groups.length - 1);
+        const lastIdx = groups.length - 1;
+        const firstUserIdx = groups.findIndex((g) => g.assistant?.role === 'user');
+        if (firstUserIdx >= 0 && firstUserIdx !== lastIdx) {
+            kept.push(groups[firstUserIdx], groups[lastIdx]);
+            oldGroups = groups.filter((_, i) => i !== firstUserIdx && i !== lastIdx);
+        }
+        else {
+            kept.push(groups[lastIdx]);
+            oldGroups = groups.slice(0, groups.length - 1);
+        }
     }
     const noop = {
         compacted: false,
@@ -319,6 +396,8 @@ export async function compactHistory(history, opts) {
                 const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
                 state.lastEstimate = estimateAfter;
                 state.lastUsage = undefined;
+                if (!layout.isLastContentRowBlank())
+                    layout.contentWrite('\n');
                 layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}强制微压缩(单组)${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
                 return {
                     compacted: true,
@@ -339,23 +418,17 @@ export async function compactHistory(history, opts) {
         }
         // history 有内容但全在保护区(系统 + 当前轮)
         if (estimateBefore >= opts.threshold * opts.window) {
+            if (!layout.isLastContentRowBlank())
+                layout.contentWrite('\n');
             layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}上下文已超阈但无可压缩项(全在保护区),建议 /clear 或缩短输入。${ui.reset}\n`);
             return { ...noop, reason: 'noop-shrunk-too-large', protectedRatio };
         }
         return { ...noop, reason: 'noop-protected', protectedRatio };
     }
-    // 第一层:微压缩——旧区原地截短(保 tool_call_id,无 LLM 调用)
-    // 覆盖三类大字段,均只裁模型/工具产物,不动 user 原话与 system(摘要):
-    //   ① tool 结果 content;
-    //   ② 旧 assistant 的 tool_calls.arguments —— provenance stub:整体超长才进,大字段
-    //     替换为 "<N 字符,已省略>"(保 path + JSON 合法,见 stubToolCallArguments);
-    //   ③ 旧 assistant 正文 content(模型长解释,回看价值低)。
-    let microcompactDone = false;
-    for (const g of oldGroups) {
-        if (microcompactGroup(g))
-            microcompactDone = true;
-    }
-    // 第二层:摘要——把旧区(微压缩后)压成一条 system 摘要
+    // 主层:摘要——把旧区【原始内容】压成一条 system 摘要。
+    // 触发压缩时旧区约占窗口 50-60%,摘要请求与摘要器共享窗口,逐条封顶后即装得下;
+    // 不在这里预跑微压缩——预截断会让摘要模型看到 600 字符残片,等于弄瞎它,
+    // 且摘要成功后旧区整体丢弃,预截断本身也无收益。
     const older = flattenGroups(oldGroups);
     const summarizeFn = opts.summarize ?? defaultSummarize;
     let summary = null;
@@ -363,7 +436,7 @@ export async function compactHistory(history, opts) {
         summary = await summarizeFn(older, opts.focus);
     }
     catch {
-        summary = null; // 摘要失败 → 回退仅微压缩,不崩
+        summary = null; // 摘要失败 → 回退微压缩兜底,不崩
     }
     if (summary) {
         const artifactRefs = collectArtifactRefs(older);
@@ -383,6 +456,10 @@ export async function compactHistory(history, opts) {
         const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
         state.lastEstimate = estimateAfter;
         state.lastUsage = undefined; // 压缩后旧 usage 失效,/context 改用校正估算
+        // 压缩行与上一个工具批次摘要行之间补空行分隔(compact 在 core step 循环顶部触发,
+        // 上一步的 batch 可能尚未 flush,缓冲末行仍是 ● 工具摘要行 → 两行黏在一起)。
+        if (!layout.isLastContentRowBlank())
+            layout.contentWrite('\n');
         layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}压缩上下文${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
         // 抖动保护:压缩后仍超阈 → 提示 /clear,不死循环
         if (estimateAfter >= opts.threshold * opts.window) {
@@ -397,11 +474,21 @@ export async function compactHistory(history, opts) {
             reason: 'summarize',
         };
     }
-    // 摘要失败:回退仅微压缩(tool content 已原地改),结构不动
+    // 摘要失败兜底:微压缩——旧区原地截短(保 tool_call_id,无 LLM 调用),结构不动。
+    // 覆盖三类大字段,均只裁模型/工具产物,不动 user 原话与 system:
+    //   ① tool 结果 content;② 旧 assistant 的 tool_calls.arguments(provenance stub,
+    //     整体超长才进,大字段替换为 "<N 字符,已省略>",保 path + JSON 合法);③ 旧 assistant 正文。
+    let microcompactDone = false;
+    for (const g of oldGroups) {
+        if (microcompactGroup(g))
+            microcompactDone = true;
+    }
     const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = estimateAfter;
     state.lastUsage = undefined; // token 数已变,旧 usage 失效
     if (microcompactDone) {
+        if (!layout.isLastContentRowBlank())
+            layout.contentWrite('\n');
         layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}微压缩旧工具结果${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
         return {
             compacted: true,

package/dist/session/persist.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
-import { config } from '../config/index.js';
+import { config, getActiveModel } from '../config/index.js';
 import { truncateDisplay } from '../ui/render.js';
 /** 会话目录(确保存在)。 */
 export function sessionDir() {
@@ -49,7 +49,7 @@ export function saveSession(history, id, queryHistory = []) {
     const meta = {
         id,
         createdAt: idToIso(id),
-        model: config.model,
+        model: getActiveModel(),
         firstUser: history.length > 1
             ? firstUserOf(history)
             : truncateDisplay((queryHistory[0] ?? '').replace(/\n/g, ' ').trim(), 40),

package/dist/session/scheduler.js

@@ -25,13 +25,13 @@ function emptyPressure(report) {
 }
 /** One scheduler instance is owned by one agent run. */
 export function createBudgetScheduler(state = contextState) {
-    const evaluate = (history, step, activeTools) => evaluateBudget(history, config.contextWindowTokens, step, state.correction, activeTools);
+    const evaluate = (history, step, activeTools, ephemeralTokens) => evaluateBudget(history, config.contextWindowTokens, step, state.correction, activeTools, ephemeralTokens);
     const scheduler = {
         lastRunLog: null,
-        async runStep(history, step, activeTools = chatTools) {
+        async runStep(history, step, activeTools = chatTools, ephemeralTokens = 0) {
             // External file changes and mutations only update artifact metadata here.
             refreshArtifactFreshness(state, history);
-            const report = evaluate(history, step, activeTools);
+            const report = evaluate(history, step, activeTools, ephemeralTokens);
             const pressure = emptyPressure(report);
             pressure.triggered = atPressure(report);
             if (pressure.triggered) {
@@ -46,7 +46,7 @@ export function createBudgetScheduler(state = contextState) {
                     const ageAware = createAgeAwareEncodingState(history);
                     pressure.encodedLogsAndSearches = ageAware.sweepPressure(history, report.hotBoundary);
                 }
-                pressure.after = evaluate(history, step, activeTools).total;
+                pressure.after = evaluate(history, step, activeTools, ephemeralTokens).total;
             }
             // Use the trigger report intentionally: cleanup may reduce the current estimate,
             // but crossing 80% commits this step to compacting for maximum token savings.

package/dist/skills/skill-eval.js

@@ -0,0 +1,345 @@
+// skill 触发评测引擎(自进化 Phase 1a)。
+//
+// 设计(docs/skill-self-evolution-research.md Part 3 Phase 1):
+//  - 评测对象是 skill 的 description(触发器),不是正文——触发不准是最常见痛点。
+//  - 载体:<skill-dir>/evals/trigger.json = [{ "query": "...", "should_trigger": true|false }, ...]
+//  - 判定:mocode 没有 Claude Code 的原生 Skill 触发事件,等价信号 = 该 query 的单轮运行里
+//    模型是否调用了 use_skill(name) / run_skill(name)。用 onToolOutcome hook 判定(拿完整 args)。
+//  - 隔离:系统提示只含该 skill 的 L0 行(name + description),工具表只给这两个工具,
+//    排除其他 skill / 工具干扰。保真度折扣(无历史上下文)在报告里如实标注(见调研 Q1)。
+//  - 噪声处理(调研共识):runs-per-query 多次运行取触发率,禁止单次跑分定生死。
+//
+// 依赖 runAgentCore:与 evals/coding/runner.ts 同构(隔离状态 + 临时沙箱 + 限步 + 超时)。
+// 纯函数(splitTriggerSet / scoreTriggerResults / applyDescription / parseTriggerEvalSet)
+// 与执行解耦,可单测。
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { runAgentCore } from '../agent/core.js';
+import { config } from '../config/index.js';
+import { beginTurn, resetState } from '../rollback/index.js';
+import { setSandboxRoot } from '../sandbox/root.js';
+import { createContextState } from '../session/compact.js';
+import { tools } from '../tools/registry.js';
+import { findSkill, buildSkillSectionFor } from './index.js';
+/** eval 集路径(与 skill 同目录,随 skill 分发;trust hash 不覆盖它——evals 不是执行面)。 */
+export function triggerEvalPath(skill) {
+    return path.join(skill.dir, 'evals', 'trigger.json');
+}
+/** 解析并校验 eval 集;文件不存在返 null;格式错误抛 Error(带诊断信息)。 */
+export function parseTriggerEvalSet(skill) {
+    const p = triggerEvalPath(skill);
+    if (!existsSync(p))
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(p, 'utf8'));
+    }
+    catch (e) {
+        throw new Error(`evals/trigger.json 不是合法 JSON: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (!Array.isArray(raw) || raw.length === 0) {
+        throw new Error('evals/trigger.json 必须是非空数组: [{ "query": "...", "should_trigger": true|false }, ...]');
+    }
+    const out = [];
+    for (let i = 0; i < raw.length; i++) {
+        const item = raw[i];
+        if (typeof item?.query !== 'string' || !item.query.trim()) {
+            throw new Error(`evals/trigger.json 第 ${i + 1} 项缺 "query"(非空字符串)`);
+        }
+        if (typeof item?.should_trigger !== 'boolean') {
+            throw new Error(`evals/trigger.json 第 ${i + 1} 项缺 "should_trigger"(true/false)`);
+        }
+        out.push({ query: item.query, should_trigger: item.should_trigger });
+    }
+    return out;
+}
+/**
+ * 分层切 train/holdout(按 should_trigger 分组各切,防过拟合)。
+ * holdout ∈ (0,1);0 表示禁用(全 train)。seeded Fisher-Yates,结果可复现。
+ */
+export function splitTriggerSet(evalSet, holdout, seed = 42) {
+    if (holdout <= 0)
+        return { train: evalSet, holdout: [] };
+    const frac = Math.min(Math.max(holdout, 0), 0.9);
+    const trigger = shuffleSeeded(evalSet.filter((e) => e.should_trigger), seed);
+    const noTrigger = shuffleSeeded(evalSet.filter((e) => !e.should_trigger), seed + 1);
+    const nT = Math.max(1, Math.round(trigger.length * frac));
+    const nN = Math.max(1, Math.round(noTrigger.length * frac));
+    return {
+        train: [
+            ...trigger.slice(nT, trigger.length),
+            ...noTrigger.slice(nN, noTrigger.length),
+        ],
+        holdout: [...trigger.slice(0, nT), ...noTrigger.slice(0, nN)],
+    };
+}
+function shuffleSeeded(arr, seed) {
+    const a = [...arr];
+    let s = seed >>> 0;
+    const rand = () => {
+        // mulberry32:小而确定,跨平台一致
+        s = (s + 0x6d2b79f5) >>> 0;
+        let t = s;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(rand() * (i + 1));
+        const tmp = a[i];
+        a[i] = a[j];
+        a[j] = tmp;
+    }
+    return a;
+}
+/**
+ * 纯评分:每 query 触发率 vs 阈值。should_trigger 需 rate ≥ threshold;
+ * 否则需 rate < threshold(边界 < 而非 ≤:恰在阈值上视为误触发,保守)。
+ */
+export function scoreTriggerResults(evalSet, runResults, threshold) {
+    return evalSet.map((e) => {
+        const triggers = runResults.get(e.query) ?? [];
+        const rate = triggers.length ? triggers.filter(Boolean).length / triggers.length : 0;
+        const pass = e.should_trigger ? rate >= threshold : rate < threshold;
+        return {
+            query: e.query,
+            should_trigger: e.should_trigger,
+            triggers: triggers.filter(Boolean).length,
+            runs: triggers.length,
+            trigger_rate: rate,
+            pass,
+        };
+    });
+}
+export function summarizeTriggerResults(results) {
+    const passed = results.filter((r) => r.pass).length;
+    return { total: results.length, passed, failed: results.length - passed, passRate: results.length ? passed / results.length : 0 };
+}
+/** 描述长度上限(开放标准:与 when_to_use 合并 1536 字;单字段取同值,保守)。 */
+export const MAX_DESCRIPTION_CHARS = 1536;
+/**
+ * 把新 description 写进 SKILL.md 的 frontmatter(纯函数,不落盘)。
+ * 支持:标量 `key: value` / 引号标量 / 块标量 `key: |`(多行)三种现状形态,
+ * 统一替换为单行标量(前提:新值不含换行与 `: `,由调用方校验)。
+ * 找不到 frontmatter 或 description 键 → 返 null(调用方生成诊断)。
+ */
+export function applyDescription(content, newDescription) {
+    const lines = content.replace(/\r\n/g, '\n').split('\n');
+    let i = 0;
+    while (i < lines.length && lines[i].trim() === '')
+        i++;
+    if (i >= lines.length || lines[i].trim() !== '---')
+        return null;
+    const start = i;
+    i++;
+    let end = -1;
+    let descLine = -1;
+    let blockEnd = -1;
+    while (i < lines.length) {
+        if (lines[i].trim() === '---') {
+            end = i;
+            break;
+        }
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('description:') && descLine === -1) {
+            descLine = i;
+            const value = lines[i].slice(lines[i].indexOf(':') + 1).trim();
+            if (value === '|' || value === '|-' || value === '>' || value === '>-') {
+                let j = i + 1;
+                while (j < lines.length && (lines[j].trim() === '' || /^\s+/.test(lines[j])) && lines[j].trim() !== '---') {
+                    j++;
+                }
+                blockEnd = j; // 块标量消费到块结束(不含)
+            }
+        }
+        i++;
+    }
+    if (end === -1 || descLine === -1)
+        return null;
+    const next = lines.slice();
+    next[descLine] = `description: ${newDescription}`;
+    // 原为块标量:删除被消费的块行(倒序删避免位移)
+    if (blockEnd !== -1) {
+        next.splice(descLine + 1, blockEnd - (descLine + 1));
+    }
+    void start;
+    return next.join('\n');
+}
+// ── 执行:单 query 触发探测 + 批量评测 ─────────────────────────────────────
+const TRIGGER_SESSION_ID = 'skill-trigger-eval';
+/** 隔离评测系统提示:身份 + 该 skill 的唯一 L0 行。确定性模板(不用 t(),保证跨语言可比)。 */
+function buildHarnessPrompt(skill, description) {
+    const section = buildSkillSectionFor([
+        { ...skill, description, modelInvocable: true },
+    ]);
+    return ('You are mocode, a terminal coding agent.\n' +
+        'A user request follows. Decide whether the single skill below is relevant to it.\n' +
+        '- If it is relevant, you MUST call use_skill with exactly this skill name, then stop and briefly say the skill instructions are loaded.\n' +
+        '- If it is not relevant, answer the request normally with plain text; do NOT call any tool.\n' +
+        '- Do not use any tool other than use_skill / run_skill.\n' +
+        section);
+}
+/**
+ * 单 query 跑一轮:返回是否触发(该轮内出现 use_skill/run_skill 且 name 匹配)。
+ * 隔离:临时沙箱根、禁权限、独立 contextState、限步、超时 abort。状态在 finally 复原。
+ * fork skill 归一为 inline 形态评测:harness 只测「模型据 description 选不选这个 skill」,
+ * 与 use_skill 返回引导语还是正文无关,归一保证评测语义一致且判定路径唯一。
+ */
+async function runSingleQuery(skill, description, query, opts) {
+    const root = mkdtempSync(path.join(tmpdir(), `mocode-skill-eval-${skill.name}-`));
+    const previousCwd = process.cwd();
+    const previousRoot = setSandboxRoot(root);
+    const previousPermission = config.permissionEnabled;
+    const previousEvalFlag = process.env.MOCODE_SKILL_EVAL;
+    process.env.MOCODE_SKILL_EVAL = '1'; // 评测内的人工调用不记使用台账(见 stats.ts)
+    config.permissionEnabled = false; // 隔离评测:run_skill 等 confirm 工具不弹面板(非 TTY fail-closed 会全拒)
+    resetState();
+    const turnId = beginTurn(query);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 60_000);
+    // 外部中断透传(AbortSignal.any 需 Node ≥20,这里手动桥接,兼容 engines>=18)
+    const externalAbort = () => controller.abort();
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            controller.abort();
+        else
+            opts.signal.addEventListener('abort', externalAbort, { once: true });
+    }
+    let triggered = false;
+    try {
+        const systemPrompt = buildHarnessPrompt({ ...skill, context: 'inline' }, description);
+        const history = [{ role: 'system', content: systemPrompt }];
+        const isTriggerCall = (tool, args) => (tool === 'use_skill' || tool === 'run_skill') &&
+            String(args?.name ?? '').trim() === skill.name;
+        await runAgentCore({
+            history,
+            userInput: query,
+            signal: controller.signal,
+            hooks: {},
+            maxSteps: opts.maxSteps ?? 4,
+            contextState: createContextState(),
+            // 工具面收窄到两个 skill 入口:排除其余工具对触发的干扰,也避免误触发的副作用面。
+            toolsOverride: tools
+                .filter((t) => t.name === 'use_skill' || t.name === 'run_skill')
+                .map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                },
+            })),
+            onTrace: () => { },
+            onToolOutcome: (tool, args) => {
+                if (isTriggerCall(tool, args)) {
+                    triggered = true;
+                    // 触发已判定:立即终止,不再跑后续步(省 token;工具执行本身被 abort 取消)。
+                    controller.abort();
+                }
+            },
+            traceContext: { sessionId: TRIGGER_SESSION_ID, turnId },
+            suppressOpeningAnalysis: true,
+        });
+    }
+    catch (e) {
+        // abort(超时/外部中断/触发后早停)或 LLM 失败:未触发即未触发,不改变判定。
+        void e;
+    }
+    finally {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener('abort', externalAbort);
+        process.chdir(previousCwd);
+        setSandboxRoot(previousRoot);
+        if (previousEvalFlag === undefined)
+            delete process.env.MOCODE_SKILL_EVAL;
+        else
+            process.env.MOCODE_SKILL_EVAL = previousEvalFlag;
+        config.permissionEnabled = previousPermission;
+        resetState();
+        rmSync(root, { recursive: true, force: true });
+    }
+    return triggered;
+}
+/**
+ * 对 eval 集批量评测一个 description:每条 query 跑 runsPerQuery 次(串行;
+ * 触发评测单轮短小,并行收益小且会放大 LLM 限流面),输出 TriggerReport。
+ */
+export async function runTriggerEval(skill, description, evalSet, runsPerQuery, threshold, opts = {}) {
+    const runResults = new Map();
+    let done = 0;
+    const total = evalSet.length * runsPerQuery;
+    for (const e of evalSet) {
+        const bools = [];
+        for (let r = 0; r < runsPerQuery; r++) {
+            if (opts.signal?.aborted)
+                throw new Error('评测被中断');
+            const hit = await runSingleQuery(skill, description, e.query, opts);
+            bools.push(hit ? 1 : 0);
+            done++;
+            opts.onProgress?.(done, total, `  [${done}/${total}] ${hit ? '✓ 触发' : '· 未触发'} ${e.query.slice(0, 60)}`);
+        }
+        runResults.set(e.query, bools);
+    }
+    const results = scoreTriggerResults(evalSet, runResults, threshold);
+    return { skill: skill.name, description, results, summary: summarizeTriggerResults(results) };
+}
+// ── CLI 输出渲染 ───────────────────────────────────────────────────────────
+/** 终端报告(人类可读)。 */
+export function renderTriggerReport(report, extra) {
+    const lines = [];
+    lines.push(`skill: ${report.skill}`);
+    lines.push(`description: ${report.description}`);
+    lines.push('');
+    for (const r of report.results) {
+        const status = r.pass ? 'PASS' : 'FAIL';
+        const expect = r.should_trigger ? '期望触发' : '期望不触发';
+        lines.push(`  [${status}] ${r.triggers}/${r.runs} (${expect}) ${r.query.slice(0, 70)}`);
+    }
+    const s = report.summary;
+    lines.push('');
+    lines.push(`汇总: ${s.passed}/${s.total} 通过 (阈值 ${extra.threshold}, 每 query ${extra.runsPerQuery} 次)`);
+    lines.push('注: 隔离评测(单轮 + 仅该 skill 的 L0 行),与完整生产上下文的触发保真度存在已知折扣。');
+    return lines.join('\n');
+}
+// ── 便捷入口:按 skill 名定位 + 读取 eval 集(带诊断)────────────────────
+export function loadSkillForEval(name) {
+    const skill = findSkill(name);
+    if (!skill)
+        throw new Error(`未找到 skill "${name}"(用 /skills 或 mocode skill eval 的帮助查看列表)`);
+    if (skill.dir === 'builtin') {
+        throw new Error(`内置 skill "${name}" 没有磁盘载体,无法做触发评测(进化对象仅限 ~/.mocode/skills 与 <cwd>/.mocode/skills)`);
+    }
+    return skill;
+}
+/** 读 eval 集;不存在时返回 null(调用方按「缺文件」处理:打印模板 + 退出)。 */
+export function loadTriggerEvalSet(skill) {
+    return parseTriggerEvalSet(skill);
+}
+/** 生成 trigger.json 模板内容(供 CLI 提示)。 */
+export function triggerEvalTemplate(skill) {
+    const cases = [
+        { query: `TODO: 一条应该触发 "${skill.name}" 的真实请求`, should_trigger: true },
+        { query: 'TODO: 一条不应触发的相近请求', should_trigger: false },
+    ];
+    return JSON.stringify(cases, null, 2);
+}
+/** 评测结果落盘目录(<cwd>/.mocode/skill-eval/);返回写入路径。 */
+export function saveTriggerReport(report) {
+    const dir = path.join(process.cwd(), '.mocode', 'skill-eval');
+    mkdirSync(dir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const p = path.join(dir, `${report.skill}-${stamp}.json`);
+    writeFileSync(p, JSON.stringify(report, null, 2), 'utf8');
+    return p;
+}
+/** 供 CLI 校验 runsPerQuery / threshold 参数(纯函数,单测覆盖)。 */
+export function validateEvalParams(runsPerQuery, threshold) {
+    if (!Number.isInteger(runsPerQuery) || runsPerQuery < 1 || runsPerQuery > 10) {
+        return 'runsPerQuery 必须是 1..10 的整数';
+    }
+    if (!(threshold > 0 && threshold <= 1)) {
+        return 'threshold 必须是 (0, 1] 的数';
+    }
+    return null;
+}