@morehao/dsh-skills-console 0.5.4 → 0.5.6

package/lib/core/hash.js

@@ -22,8 +22,28 @@ function collectFiles(dir, out) {
 }
 
 /**
- * 逐字复刻 skills CLI 的内容哈希（F6）：
- * 只收普通文件 → 跳过 `.git` / `node_modules` → 相对路径 `/` 归一 → localeCompare 排序
+ * 排序口径：UTF-16 code unit 序（等价 `Array#sort()` 默认序），**与进程 locale 无关**。
+ *
+ * 绝不能用 `localeCompare`：它按默认 locale 的 collation 比较，同一个目录在不同
+ * LANG / ICU 版本下会排出不同顺序，同一份内容就能算出两个哈希。真实案例：
+ * `script.md` 与 `什么是token.html` 在 en 下 script 在前、在 zh 下汉字在前，
+ * 于是「安装时 en、读时 zh」的技能被误报成「本地已改」。
+ */
+export function comparePaths(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * 旧口径（v0.6.x 之前）：进程 / 显式 locale 的 collation。
+ * 只用于识别历史基线（`matchesLegacyHash`），不得用于写新基线。
+ */
+export function localeComparator(locale) {
+  return (a, b) => a.localeCompare(b, locale);
+}
+
+/**
+ * 目录内容哈希（F6）：
+ * 只收普通文件 → 跳过 `.git` / `node_modules` → 相对路径 `/` 归一 → code unit 排序
  * → 先 update(路径) 再 update(内容) → sha256。
  *
  * 用途只有一个：进 L1「本地有没有被改过」的基线，绝不与上游 tree SHA 混用。
@@ -36,12 +56,13 @@ export function contentHash(dir) {
  * 同 `contentHash`，但允许按相对路径改写文件内容后再参与哈希。
  * `transform(rel, buffer)` 返回 Buffer；返回 `null` 表示无法归一化（调用方保守处理）。
  * 用于「仅手动」：把插件写入的 frontmatter 行按 state 还原后再与基线比较。
+ * `compare` 只给历史基线识别用，正常路径保持默认的 locale 无关排序。
  */
-export function contentHashWith(dir, transform = null) {
+export function contentHashWith(dir, transform = null, compare = comparePaths) {
   const files = collectFiles(dir, []).map((file) =>
     path.relative(dir, file).split(path.sep).join('/'),
   );
-  files.sort((a, b) => a.localeCompare(b));
+  files.sort(compare);
   const hash = crypto.createHash('sha256');
   for (const rel of files) {
     const raw = fs.readFileSync(path.join(dir, rel));

package/lib/core/intro-store.js

@@ -33,6 +33,8 @@ function sanitizeEntry(entry) {
     inputBytes: Number.isFinite(entry.inputBytes) ? entry.inputBytes : null,
     truncated: Boolean(entry.truncated),
     sourceBytes: Number.isFinite(entry.sourceBytes) ? entry.sourceBytes : null,
+    maxTokens: Number.isFinite(entry.maxTokens) ? entry.maxTokens : null,
+    finish: typeof entry.finish === 'string' ? entry.finish : 'stop',
   };
 }
 
@@ -125,10 +127,11 @@ export function createIntroStore({ paths, logger = () => {} }) {
       return problem;
     },
     load,
-    /** 读一条缓存；没有就是 null。返回浅拷贝，调用方改不坏内存表。 */
+    /** 读一条缓存；没有就是 null。只有 `finish: stop` 的完整简介才会被返回。 */
     get(name, lang) {
       const entry = load().items[name]?.[lang];
-      return entry ? { ...entry } : null;
+      if (!entry || entry.finish !== 'stop') return null;
+      return { ...entry };
     },
     /** 写一条缓存；写盘失败不影响返回值（介绍已经拿到了）。 */
     put(name, lang, entry) {

package/lib/core/intro.js

@@ -19,9 +19,10 @@ import { sha256 } from './hash.js';
 
 /**
  * 简介缓存的格式版本（与 state 的版本无关，坏了直接当空表）。
- * v3 = 简介必须写清触发方式 / 触发关键词；v2 的旧条目只讲能力，直接丢弃重建。
+ * v4 = 只缓存 `finish: stop` 的完整简介；v3 及更早的条目（含 300 token 上限下
+ * 产生的截断文本）全部丢弃重建。
  */
-export const INTRO_STORE_VERSION = 3;
+export const INTRO_STORE_VERSION = 4;
 
 /** 介绍语言：跟随界面语言，只支持这两档。 */
 export const INTRO_LANGS = Object.freeze(['zh', 'en']);
@@ -31,20 +32,30 @@ export const INTRO_LIMITS = Object.freeze({
   minInputBytes: 8 * 1024,
   maxInputBytes: 48 * 1024,
   minOutputTokens: 96,
-  maxOutputTokens: 1024,
+  maxOutputTokens: 8_192,
   minTimeoutMs: 5_000,
   maxTimeoutMs: 60_000,
   /** 单条简介的字符上限（提示词要 160 字并含触发句，留出余量后兜底） */
   maxIntroChars: 400,
 });
 
+/**
+ * 输出预算的保底值：`maxOutputTokens` 是「防跑飞上限」，不是长度目标。
+ * 推理模型的思考 token 与正文共用同一份输出预算，300 这种小上限会被思考吃光；
+ * 因此推理模型至少 4096，普通模型至少 1024（400 字符中文也可能超过 300 token）。
+ */
+export const INTRO_OUTPUT_FLOOR = Object.freeze({
+  plain: 1_024,
+  reasoning: 4_096,
+});
+
 export const DEFAULT_INTRO_CONFIG = Object.freeze({
   enabled: true,
   provider: null,
   model: null,
   maxInputBytes: 24 * 1024,
-  maxOutputTokens: 300,
-  timeoutMs: 30_000,
+  maxOutputTokens: 4_096,
+  timeoutMs: 60_000,
 });
 
 /** 调用/准备阶段的失败，由 Service 转成带 HTTP 状态的错误。 */
@@ -326,7 +337,7 @@ function failureFrom(error) {
  * @param {{system: string, input: string}} options.prompt
  * @param {number} options.maxOutputTokens
  * @param {AbortSignal} [options.signal]
- * @returns {Promise<{ text: string, usage: object|null, provider: string, model: string }>}
+ * @returns {Promise<{ text: string, usage: object|null, provider: string, model: string, maxTokens: number, reasoningEffort: string|null, finish: string }>}
  */
 export async function runIntroCall({ llm, route, prompt, maxOutputTokens, signal }) {
   if (!llm || (typeof llm.prepareCall !== 'function' && typeof llm.stream !== 'function')) {
@@ -345,16 +356,29 @@ export async function runIntroCall({ llm, route, prompt, maxOutputTokens, signal
     },
   ];
 
+  // 输出上限是「防跑飞预算」，不是长度目标：推理 token 也计入这里。
+  // 推理模型至少 4096，普通模型至少 1024，避免思考吃光预算后正文为空。
+  const requestedMaxTokens = Math.max(
+    Number.isFinite(maxOutputTokens) ? maxOutputTokens : DEFAULT_INTRO_CONFIG.maxOutputTokens,
+    INTRO_OUTPUT_FLOOR.plain,
+  );
+
   let call = null;
   try {
     if (typeof llm.prepareCall === 'function') {
       call = await llm.prepareCall(
-        { provider: route.provider, model: route.model, maxTokens: maxOutputTokens },
+        { provider: route.provider, model: route.model, maxTokens: requestedMaxTokens },
         signal,
         (controls, model) => {
+          const floor = model?.reasoning ? INTRO_OUTPUT_FLOOR.reasoning : INTRO_OUTPUT_FLOOR.plain;
+          const modelCap = Number.isFinite(model?.defaultMaxTokens) ? model.defaultMaxTokens : Infinity;
           // 介绍不需要长思考：取适配器公布的最低推理强度，压低首字延迟与成本。
           const lowest = model?.reasoning?.efforts?.[0]?.id;
-          return lowest ? { ...controls, reasoningEffort: lowest } : controls;
+          return {
+            ...controls,
+            maxTokens: Math.max(controls.maxTokens ?? 0, Math.min(floor, modelCap)),
+            ...(lowest ? { reasoningEffort: lowest } : {}),
+          };
         },
       );
     }
@@ -362,42 +386,96 @@ export async function runIntroCall({ llm, route, prompt, maxOutputTokens, signal
     throw failureFrom(error);
   }
 
+  const fallbackMaxTokens = Math.max(requestedMaxTokens, INTRO_OUTPUT_FLOOR.reasoning);
   const options = call
     ? { ...call.config, messages, system: prompt.system, signal }
     : {
         provider: route.provider,
         model: route.model,
-        maxTokens: maxOutputTokens,
+        maxTokens: fallbackMaxTokens,
         messages,
         system: prompt.system,
         signal,
       };
 
-  let text = '';
+  let deltaText = '';
+  let sawTextDelta = false;
+  const textBlocks = new Map();
+  let reasoningChars = 0;
   let usage = null;
   let finish = null;
   try {
     const stream = call ? call.stream(options) : llm.stream(options);
     for await (const chunk of stream) {
       if (!chunk || typeof chunk !== 'object') continue;
-      if (chunk.type === 'text-delta') text += typeof chunk.text === 'string' ? chunk.text : '';
-      else if (chunk.type === 'usage') usage = chunk.usage || null;
-      else if (chunk.type === 'finish') finish = chunk.reason || null;
+      if (chunk.type === 'text-delta') {
+        sawTextDelta = true;
+        if (typeof chunk.text === 'string') deltaText += chunk.text;
+      } else if (chunk.type === 'reasoning-delta') {
+        if (typeof chunk.text === 'string') reasoningChars += chunk.text.length;
+      } else if (chunk.type === 'block-end') {
+        const block = chunk.block;
+        if (block?.type === 'text' && typeof block.text === 'string') {
+          textBlocks.set(chunk.index, block.text);
+        } else if (block?.type === 'reasoning' && typeof block.text === 'string') {
+          reasoningChars = Math.max(reasoningChars, block.text.length);
+        }
+      } else if (chunk.type === 'usage') {
+        usage = chunk.usage || null;
+      } else if (chunk.type === 'finish') {
+        finish = chunk.reason || null;
+      }
     }
   } catch (error) {
     throw failureFrom(error);
   }
 
-  if (finish && finish.kind !== 'stop' && finish.kind !== 'max-tokens') {
-    throw failureFrom({ failure: finish.failure || null, code: finish.kind === 'aborted' ? 'ABORTED' : null });
+  const effectiveMaxTokens = Number.isFinite(options.maxTokens) ? options.maxTokens : requestedMaxTokens;
+  const kind = finish?.kind || 'stop';
+
+  if (kind === 'aborted') {
+    throw failureFrom({ failure: finish?.failure || null, code: 'ABORTED' });
+  }
+  if (kind === 'error') {
+    throw failureFrom({ failure: finish?.failure || null, code: null });
+  }
+  if (kind === 'max-tokens') {
+    throw new IntroError(
+      'error.skills.intro-truncated',
+      '简介达到输出上限被截断，请重试或调大 intro.maxOutputTokens',
+      { finish: kind, maxTokens: effectiveMaxTokens, usage },
+      502,
+    );
+  }
+  if (kind === 'tool-calls') {
+    throw new IntroError(
+      'error.skills.intro-no-text',
+      '模型没有输出文字简介（尝试调用工具），请重试',
+      { finish: kind, maxTokens: effectiveMaxTokens, usage },
+      502,
+    );
+  }
+  if (kind !== 'stop') {
+    throw failureFrom({ failure: finish?.failure || null, code: null });
   }
 
+  // 块式适配器可能不给 text-delta，回退用 block-end 里的 text block。
+  const text = sawTextDelta ? deltaText : [...textBlocks.values()].join('');
   const cleaned = cleanIntroText(text);
   if (!cleaned) {
+    const produced = reasoningChars > 0 || Number(usage?.outputTokens) > 0;
+    if (produced) {
+      throw new IntroError(
+        'error.skills.intro-reasoning-only',
+        '模型只输出了思考过程、没有输出简介正文，请提高输出上限或换一个非推理模型',
+        { finish: kind, maxTokens: effectiveMaxTokens, usage, reasoningChars },
+        502,
+      );
+    }
     throw new IntroError(
       'error.skills.intro-empty',
-      '模型没有返回内容，请重试或换一个模型',
-      { finish: finish?.kind || null },
+      '模型没有返回内容，请重试',
+      { finish: kind, maxTokens: effectiveMaxTokens, usage },
       502,
     );
   }
@@ -407,6 +485,9 @@ export async function runIntroCall({ llm, route, prompt, maxOutputTokens, signal
     usage,
     provider: route.provider,
     model: route.model,
+    maxTokens: effectiveMaxTokens,
+    reasoningEffort: options.reasoningEffort || null,
+    finish: kind,
   };
 }
 
@@ -416,7 +497,18 @@ export function introKey(name, lang) {
 }
 
 /** 汇总一次生成的元信息（缓存条目与响应共用）。 */
-export function introEntry({ text, hash, provider, model, usage, inputBytes, truncated, sourceBytes }) {
+export function introEntry({
+  text,
+  hash,
+  provider,
+  model,
+  usage,
+  inputBytes,
+  truncated,
+  sourceBytes,
+  maxTokens = null,
+  finish = 'stop',
+}) {
   return {
     hash,
     text,
@@ -427,6 +519,8 @@ export function introEntry({ text, hash, provider, model, usage, inputBytes, tru
     inputBytes,
     truncated: Boolean(truncated),
     sourceBytes: sourceBytes ?? inputBytes,
+    maxTokens: Number.isFinite(maxTokens) ? maxTokens : null,
+    finish,
   };
 }
 

package/lib/core/invocation.js

@@ -2,7 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { contentHashWith } from './hash.js';
+import { contentHashWith, localeComparator } from './hash.js';
 
 /**
  * 「自动 / 仅手动 / 完全停用」的落盘层。
@@ -527,7 +527,11 @@ export function unparkSkill({ dir, name, fallbackMode = 'auto', keep = null }) {
   let hashMismatch = false;
   if (marker?.canonicalHash) {
     const current = contentHashWith(dir);
-    hashMismatch = current !== null && current !== marker.canonicalHash;
+    // 旧版 marker 里的哈希是按 locale collation 排出来的；换 locale 后同一份内容
+    // 也会对不上，先按旧口径复核一次，避免把「排序变了」报成「内容漂移」。
+    hashMismatch = current !== null
+      && current !== marker.canonicalHash
+      && !matchesLegacyHash(dir, null, marker.canonicalHash);
   }
   const previousMode = (marker?.previousMode === 'manual' || marker?.previousMode === 'auto')
     ? marker.previousMode
@@ -547,9 +551,11 @@ export function unparkSkill({ dir, name, fallbackMode = 'auto', keep = null }) {
  * 归一化哈希：把插件写入的 `disable-model-invocation: true` 按 state 还原后再算目录哈希。
  * 只有 origin='plugin' 才归一化；author 声明属于上游内容，必须原样计入。
  * 解析失败 / 当前值不是 true 时返回 null —— 调用方保守判为「本地有改动」。
+ *
+ * `compare` 仅供 `matchesLegacyHash` 复核旧口径使用；新基线一律用默认的 locale 无关排序。
  */
-export function hashWithoutInvocation(dir, manual) {
-  if (!manual || manual.origin !== 'plugin') return contentHashWith(dir);
+export function hashWithoutInvocation(dir, manual, compare) {
+  if (!manual || manual.origin !== 'plugin') return contentHashWith(dir, null, compare);
   const expected = manual.original;
   if (expected !== 'absent' && expected !== 'false') return null;
   return contentHashWith(dir, (relative, buffer) => {
@@ -565,7 +571,27 @@ export function hashWithoutInvocation(dir, manual) {
     if (expected === 'absent') lines.splice(parsed.keyIndex, 1);
     else lines[parsed.keyIndex] = renderLine(lines[parsed.keyIndex], 'false');
     return Buffer.from(join(parsed, lines), 'utf8');
-  });
+  }, compare);
+}
+
+/**
+ * 旧基线识别：v0.6.x 之前的内容哈希按进程 locale 的 collation 排序，同一份内容
+ * 换 locale / ICU 版本就会得到不同 digest。用几个最常见的 collation 反查，
+ * 命中即说明「内容没变、只是排序口径变了」，可以安全地把基线改写成新口径。
+ *
+ * 只是识别手段：某个旧口径能精确复现记录值，等价于内容逐字节相同。
+ */
+export function matchesLegacyHash(dir, manual, digest) {
+  if (typeof digest !== 'string' || !digest) return false;
+  const defaultLocale = new Intl.Collator().resolvedOptions().locale;
+  // 覆盖最常见的几类 collation：拉丁（en）、中文（zh）、日文（ja）。
+  // 都不命中就保守地维持「本地已改」，让用户确认 —— 绝不靠猜去改基线。
+  const locales = new Set([defaultLocale, 'en', 'zh', 'ja']);
+  for (const locale of locales) {
+    const compare = locale === defaultLocale ? undefined : localeComparator(locale);
+    if (hashWithoutInvocation(dir, manual, compare) === digest) return true;
+  }
+  return false;
 }
 
 /** 供 Host 层判断「这行到底是不是被 park 了」，不读 state。 */