c0de-agent 1.13.0 → 1.14.0

package/dist/tools/executor.js

@@ -1,6 +1,20 @@
+import { MAX_TIMER_MS } from '../shared/timer.js';
 import { getTool } from './registry.js';
 import { truncateOutput } from './truncate.js';
 import { validateInput } from './validate.js';
+/**
+ * 归一化工具声明的超时（ms）。返回 null = 无超时（直接执行）。
+ * ToolDef.timeout 是插件/内置工具代码，不是用户输入：退化声明（缺失/非正/
+ * 非有限）按「无超时」放行（fail-open，与 timeout: undefined 同语义）；
+ * 有限正值超 32 位 timer 上限（2^31-1）时钳制到上限——不钳的话 Node 的
+ * setTimeout 会把 >2^31-1 的延迟钳到 1ms，工具每次调用都被瞬间「超时」击毙，
+ * 且错误信息谎报原始时长。
+ */
+function normalizeToolTimeout(timeout) {
+    if (timeout === undefined || !Number.isFinite(timeout) || timeout <= 0)
+        return null;
+    return Math.min(timeout, MAX_TIMER_MS);
+}
 /**
  * Execute a tool by name with full pipeline:
  * find tool → validate input → check permission → execute → truncate output.
@@ -32,7 +46,16 @@ export async function executeTool(registry, name, input, ctx, permissionChecker)
     }
     // 4. Execute
     try {
-        const result = await tool.execute(input, ctx);
+        // ToolDef.timeout 声明必须兑现：此前直接 await tool.execute，声明的超时
+        // （websearch 30s）从未执行——后端 fetch 挂起时整个 agent run 无限期挂死，
+        // 只有用户手动 abort 才能脱身。超时经派生 AbortController 注入工具 ctx：
+        // 底层 IO（fetch 等）随超时取消，不再后台残留；外层 run abort 同样级联。
+        // 声明先经 normalizeToolTimeout 归一化：退化值=无超时，超 32 位上限钳到
+        // 上限（否则 setTimeout 把 >2^31-1 钳到 1ms，工具被瞬间击毙）。
+        const timeout = normalizeToolTimeout(tool.timeout);
+        const result = timeout !== null
+            ? await executeWithTimeout(tool, input, ctx, timeout)
+            : await tool.execute(input, ctx);
         // 5. Truncate large output
         if (result._tag === 'success') {
             const truncated = truncateOutput(result.output);
@@ -52,3 +75,32 @@ export async function executeTool(registry, name, input, ctx, permissionChecker)
         return { _tag: 'error', error: `Tool "${name}" failed: ${message}` };
     }
 }
+/**
+ * 在声明超时内执行工具：派生 abort 信号（外层 run abort 级联），超时先 abort
+ * 再以明确错误拒绝。Promise.race 的晚到 resolve 被忽略；工具自身若无视 abort
+ * 继续执行，其结果被丢弃，但错误信息与超时语义不受影响。
+ * timeout 已由调用方经 normalizeToolTimeout 归一化（有限正值且 ≤ 32 位上限）。
+ */
+async function executeWithTimeout(tool, input, ctx, timeout) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    ctx.abort.addEventListener('abort', onAbort, { once: true });
+    let timer;
+    try {
+        return await Promise.race([
+            tool.execute(input, { ...ctx, abort: controller.signal }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    // 外层 catch 会加 "Tool \"x\" failed:" 前缀，这里不再重复工具名
+                    reject(new Error(`timed out after ${timeout}ms`));
+                }, timeout);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        ctx.abort.removeEventListener('abort', onAbort);
+    }
+}

package/dist/tools/hashline/patch.js

@@ -6,36 +6,72 @@ function computeHash(content) {
 }
 // ── parsePatch ───────────────────────────────────────────
 const HEADER_RE = /^\[(.+?)#([0-9a-fA-F]+)\]\s*$/;
-/** 解析一个 `[path#hash]` 块内的操作序列。lines 为该块头之后的行。 */
+/** 解析一个 `[path#hash]` 块内的操作序列。lines 为该块头之后的全部剩余行。
+ *  返回 { ops, consumed }：consumed 是本次消费的行数（含块间分隔空行，
+ *  不含下一块头行）——parsePatch 据此推进。
+ *
+ *  结构感知：块头只在「操作位置」生效——以 `---` 显式终止的操作，其内容里的
+ *  任何行（含 [path#hash] 形行、操作语法形行）都是内容；`---` 缺失时以
+ *  下一个操作行/块头为隐式边界。 */
 function parseOps(lines) {
     const ops = [];
     let i = 0;
     while (i < lines.length) {
-        const line = lines[i];
-        if (!line || line.trim() === '') {
+        const line = lines[i] ?? '';
+        if (line.trim() === '' || isSeparator(line)) {
             i++;
             continue;
         }
+        if (HEADER_RE.test(line.trim()))
+            break; // 下一块头：操作位置生效
         const tokens = line.split(/\s+/);
         const head = tokens[0];
         if (!head)
             throw new Error('hashline: empty operation line');
-        // 收集到下一个分隔符 `---`（或块尾）的内容行
+        // 候选边界行之后是否先出现 `---`：是则该候选行是内容（显式终止符
+        // 优先于一切），否则该候选行就是边界。
+        const isContentLine = (at) => {
+            for (let k = at + 1; k < lines.length; k++) {
+                const lk = lines[k] ?? '';
+                if (isSeparator(lk))
+                    return true;
+                if (isOpLine(lk) || HEADER_RE.test(lk.trim()))
+                    return false;
+            }
+            return false;
+        };
+        // 收集到显式 `---`、或（无 `---` 时）到下一个操作行/块头/文件尾的内容行。
         const collectContent = () => {
             const body = [];
             let j = i + 1;
-            while (j < lines.length && lines[j] !== '---') {
-                body.push(lines[j] ?? '');
+            while (j < lines.length) {
+                const l = lines[j] ?? '';
+                if (isSeparator(l))
+                    return { content: body.join('\n'), next: j + 1 };
+                if ((isOpLine(l) || HEADER_RE.test(l.trim())) && !isContentLine(j))
+                    break;
+                body.push(l);
                 j++;
             }
-            return { content: body.join('\n'), next: j + 1 };
+            // 隐式终止（无 --- 的块）：块间分隔空行不是内容，剥离恰好一个
+            //（内容里合法结尾空行由倒数第二个空串表达，与既有口径一致）。
+            if (body.length > 0 && body[body.length - 1] === '')
+                body.pop();
+            return { content: body.join('\n'), next: j };
         };
-        // 无内容体（DEL）也吃掉到 `---`
+        // DEL 无内容体：跳到显式 `---` 或下一个操作行/块头（无 --- 的多操作补丁
+        // 里，后续操作不得被当「要跳过的内容」吞掉）。
         const skipToSeparator = () => {
             let j = i + 1;
-            while (j < lines.length && lines[j] !== '---')
+            while (j < lines.length) {
+                const l = lines[j] ?? '';
+                if (isSeparator(l))
+                    return j + 1;
+                if (isOpLine(l) || HEADER_RE.test(l.trim()))
+                    return j;
                 j++;
-            return j + 1;
+            }
+            return j;
         };
         if (head === 'SWAP') {
             const [s, e] = parseRange(tokens[1]);
@@ -50,12 +86,12 @@ function parseOps(lines) {
         }
         else if (head === 'INS.PRE') {
             const { content, next } = collectContent();
-            ops.push({ _tag: 'INS_PRE', line: Number(tokens[1]), content });
+            ops.push({ _tag: 'INS_PRE', line: parseLineNumber(tokens[1]), content });
             i = next;
         }
         else if (head === 'INS.POST') {
             const { content, next } = collectContent();
-            ops.push({ _tag: 'INS_POST', line: Number(tokens[1]), content });
+            ops.push({ _tag: 'INS_POST', line: parseLineNumber(tokens[1]), content });
             i = next;
         }
         else if (head === 'INS.HEAD') {
@@ -72,17 +108,43 @@ function parseOps(lines) {
             throw new Error(`hashline: unknown operation "${head}"`);
         }
     }
-    return ops;
+    return { ops, consumed: i };
+}
+/** 操作行的完整语法（用于内容边界判定；宽容行尾空白）。 */
+const OP_LINE_RE = /^(?:SWAP|DEL)\s+\d+(?:-\d+)?\s*$|^INS\.(?:PRE|POST)\s+\d+\s*$|^INS\.(?:HEAD|TAIL)\s*$/;
+function isOpLine(line) {
+    return OP_LINE_RE.test(line);
+}
+/**
+ * 显式操作终止符 `---`。编辑器/模型产物常带尾随空白（`--- `、`---\t`）或缩进
+ * （` --- `）——此前只做全等比较，空白变体被当内容行收进替换内容（文件凭空
+ * 多出 "--- " 一行）、后续操作静默变成文本/被跳过，工具仍报 success。
+ * 空白变体与 `---` 视觉等价，统一视为终止符（与「`---` 恒为终止符、不能做
+ * 内容」的既有口径一致）。CRLF 补丁文本的行尾 \r 也由 \s 覆盖。
+ */
+function isSeparator(line) {
+    return /^\s*---\s*$/.test(line);
 }
-/** 解析 `start` 或 `start-end`，返回 [start, end?]（1-indexed）。 */
+/**
+ * 解析 `start` 或 `start-end`，返回 [start, end?]（1-indexed 十进制整数）。
+ * 非十进制整数（小数/十六进制/科学计数/尾随垃圾）显式抛错：Number('1.5') 会
+ * 通过 inBounds 后被 splice 静默截断、Number('0x10')=16——垃圾行号静默命中错误行。
+ */
 function parseRange(spec) {
     if (!spec)
         throw new Error('hashline: missing line range');
-    if (spec.includes('-')) {
-        const [a, b] = spec.split('-');
-        return [Number(a), Number(b)];
+    const parts = spec.split('-');
+    if (parts.length > 2 || parts.some((p) => !/^\d+$/.test(p))) {
+        throw new Error(`hashline: invalid line range "${spec}" (decimal integers expected)`);
     }
-    return [Number(spec), undefined];
+    return [Number(parts[0]), parts[1] !== undefined ? Number(parts[1]) : undefined];
+}
+/** 解析单行号（INS.PRE/POST 用），与 parseRange 同口径严格校验。 */
+function parseLineNumber(spec) {
+    if (spec === undefined || !/^\d+$/.test(spec)) {
+        throw new Error(`hashline: invalid line number "${spec ?? ''}" (decimal integer expected)`);
+    }
+    return Number(spec);
 }
 /** 解析补丁文本为一个或多个 ParsedPatch（按 `[path#hash]` 头分块）。 */
 function parsePatch(input) {
@@ -100,20 +162,12 @@ function parsePatch(input) {
             throw new Error(`hashline: malformed header "${line}"`);
         const path = m[1] ?? '';
         const hash = m[2] ?? '';
-        const block = lines.slice(i + 1);
-        const endIdx = block.indexOf(''); // 块以空行或文件尾分隔（其实下一头才分隔）
-        // 操作持续到下一个头或文件尾：找到下一个 HEADER_RE 匹配行
-        let nextHead = block.length;
-        for (let k = 0; k < block.length; k++) {
-            if (HEADER_RE.test((block[k] ?? '').trim())) {
-                nextHead = k;
-                break;
-            }
-        }
-        void endIdx;
-        const opsLines = block.slice(0, nextHead);
-        patches.push({ path, hash, operations: parseOps(opsLines) });
-        i = i + 1 + nextHead;
+        // 结构感知解析：块头只会在「操作位置」终止上一个块——`---` 终止的操作
+        // 其内容里的 [path#hash] 形行是内容而非新块（此前恒按块头扫描，合法
+        // 内容被拦腰截断、残余行被当作操作解析报 unknown operation）。
+        const { ops, consumed } = parseOps(lines.slice(i + 1));
+        patches.push({ path, hash, operations: ops });
+        i = i + 1 + consumed;
     }
     return patches;
 }
@@ -134,6 +188,16 @@ function anchor(op, lineCount) {
             return lineCount + 1;
     }
 }
+/** 同锚点操作的次级排序键：**消耗锚点行的操作（SWAP/DEL）先于插入操作**。
+ *  锚点只保证「高行号先改、低行号不受影响」；锚点相同时（INS.HEAD 与 SWAP 1-1、
+ *  INS.PRE n 与 SWAP n / DEL n、INS.POST n 与 SWAP n+1 均锚在同一行）按补丁顺序
+ *  稳定排序会让插入先执行——插入内容占据该行下标，随后 SWAP/DEL 恰好吃掉它：
+ *  插入行消失、原行未被替换/删除（两个操作都没生效，工具仍报 success）。
+ *  先消耗后插入是唯一同时满足两侧语义的顺序：行被替换/删除后，插入内容落在
+ *  该行位置的「之前」，仍紧邻原本要插入的锚点。 */
+function applyRank(op) {
+    return op._tag === 'SWAP' || op._tag === 'DEL' ? 0 : 1;
+}
 /** 校验操作的行号范围是否落在 [1, lineCount]。 */
 function inBounds(op, lineCount) {
     switch (op._tag) {
@@ -157,7 +221,13 @@ function applyPatch(file, patch) {
     // 末尾换行保留策略：按 \n 拆分，末尾空串代表文件以换行结尾。
     const hadTrailingNewline = file.endsWith('\n');
     const src = hadTrailingNewline ? file.slice(0, -1) : file;
-    const lines = src.split('\n');
+    // CRLF 行尾：行 token 剥离 \r 参与行算术，输出按检测到的行尾重建。
+    // 此前 split('\n') 后行内残留 \r——SWAP 替换整行（含其 \r）、INS 插入行
+    // 用 \n 连接，编辑/插入行静默丢失 \r，与未触碰行混成 CRLF/LF 混合行尾。
+    // 无 \n 的孤立 \r（LF 判定下）是文件内容而非行尾，保持原样。
+    const eol = src.includes('\r\n') ? '\r\n' : '\n';
+    const stripCR = (l) => (l.endsWith('\r') ? l.slice(0, -1) : l);
+    const lines = src.split('\n').map((l) => (eol === '\r\n' ? stripCR(l) : l));
     const lineCount = lines.length;
     // 先全部校验范围，任一越界即 line_not_found（保持原文件不变）
     for (const op of patch.operations) {
@@ -165,13 +235,19 @@ function applyPatch(file, patch) {
             return { _tag: 'line_not_found', operation: op };
         }
     }
-    // 按锚点降序应用：高行号先改，低行号锚点不受影响
+    // 按锚点降序应用：高行号先改，低行号锚点不受影响。
+    // 锚点相同（INS.HEAD / INS.PRE n / INS.POST n-1 与 SWAP·DEL 落在同一行）时
+    // 先应用消耗该行的 SWAP/DEL，再应用插入（见 applyRank：否则插入内容被吞掉）。
     const ordered = [...patch.operations].sort((a, b) => {
         const lineCountFinal = lineCount;
-        return anchor(b, lineCountFinal) - anchor(a, lineCountFinal);
+        return anchor(b, lineCountFinal) - anchor(a, lineCountFinal) || applyRank(a) - applyRank(b);
     });
     for (const op of ordered) {
-        const contentLines = 'content' in op && op.content !== '' ? op.content.split('\n') : [];
+        // 补丁内容行按文件行尾归一：模型粘贴 CRLF 内容时先剥行尾 \r 再按 eol 重建，
+        // 与文件其余部分保持单一换行风格。剥离对 LF 内容是无操作——此前只在
+        // eol===CRLF 时剥离，LF 文件 + CRLF 补丁内容的行残留 \r，与其余行混成
+        // CRLF/LF 混合行尾（与 edit diff 模式的单向归一化同型）。
+        const contentLines = 'content' in op && op.content !== '' ? op.content.split('\n').map(stripCR) : [];
         switch (op._tag) {
             case 'SWAP':
                 lines.splice(op.start - 1, op.end - op.start + 1, ...contentLines);
@@ -193,9 +269,9 @@ function applyPatch(file, patch) {
                 break;
         }
     }
-    let result = lines.join('\n');
+    let result = lines.join(eol);
     if (hadTrailingNewline)
-        result += '\n';
+        result += eol;
     return { _tag: 'success', content: result };
 }
 export { applyPatch, computeHash, parsePatch };

package/dist/tools/truncate.js

@@ -1,3 +1,4 @@
+import { headChars, tailChars } from '../shared/utils/string.js';
 /** Default truncation thresholds — tuned for LLM context windows. */
 export const DEFAULT_TRUNCATE_OPTIONS = {
     maxLines: 2000,
@@ -22,29 +23,57 @@ export function truncateOutput(output, opts = DEFAULT_TRUNCATE_OPTIONS) {
     if (!needsLineTrunc && !needsCharTrunc) {
         return { output, truncated: false, totalLines, totalChars };
     }
+    // 字符截断（保留 head/tail 各半）。
+    // 标记长度计入预算：此前 head+tail 吃满 maxChars 后追加标记，输出反而
+    // 比原文更长且突破上限（如 100_001 字符 → 100_029 字符）。
+    const truncateByChars = (text) => {
+        const total = text.length;
+        const markerFor = (omitted) => `\n[... ${omitted} chars truncated ...]\n`;
+        let marker = '';
+        let keepChars = opts.maxChars;
+        for (;;) {
+            const omitted = total - keepChars;
+            const next = markerFor(omitted);
+            if (next === marker)
+                break; // 数字位数不再变化，收敛
+            marker = next;
+            keepChars = Math.max(0, opts.maxChars - marker.length);
+        }
+        // 上限连标记自身都放不下（maxChars 小于标记长度）：无标记硬截断，
+        // 保住「输出 ≤ maxChars」不变量（此前 marker 恒长于预算仍被输出）。
+        if (marker.length >= opts.maxChars) {
+            return headChars(text, opts.maxChars);
+        }
+        const headLen = Math.floor(keepChars / 2);
+        const tailLen = keepChars - headLen;
+        // 切点代理对安全：head/tail 各取至多 headLen/tailLen 字符，
+        // 内收只会缩短输出，marker 计入预算后的 ≤ maxChars 不变量保持。
+        return headChars(text, headLen) + marker + tailChars(text, tailLen);
+    };
     // Line-based truncation takes priority
     if (needsLineTrunc) {
         const head = lines.slice(0, opts.headLines);
         const tailStart = totalLines - opts.tailLines;
-        // If tail would overlap head, show only head + marker
-        if (tailStart <= opts.headLines) {
-            const omitted = totalLines - head.length;
-            const marker = `[... ${omitted} lines truncated ...]`;
-            return { output: [...head, marker].join('\n'), truncated: true, totalLines, totalChars };
-        }
-        const tail = lines.slice(tailStart);
+        // tail 与 head 重叠（或 tailLines ≥ totalLines）→ 只保留 head
+        const tail = tailStart > opts.headLines ? lines.slice(tailStart) : [];
         const omitted = totalLines - head.length - tail.length;
+        // head 已覆盖全部行（headLines ≥ totalLines）→ 无任何省略：
+        // 此前恒插 "[... 0 lines truncated ...]"，输出比原文多一行且行数突破
+        // maxLines。直接原样返回；字符超限时仍走字符兜底截断。
+        if (omitted === 0) {
+            if (needsCharTrunc) {
+                return { output: truncateByChars(output), truncated: true, totalLines, totalChars };
+            }
+            return { output, truncated: false, totalLines, totalChars };
+        }
         const marker = `[... ${omitted} lines truncated ...]`;
         const result = [...head, marker, ...tail].join('\n');
+        // 行截断后仍可能突破字符上限：head/tail 行自身巨大（minified 单行）或
+        // 省略行全为空而标记把长度顶过上限——此时再按字符截断兜底，保证 ≤ maxChars。
+        if (result.length > opts.maxChars) {
+            return { output: truncateByChars(result), truncated: true, totalLines, totalChars };
+        }
         return { output: result, truncated: true, totalLines, totalChars };
     }
-    // Char-based truncation (keep proportional head/tail of chars)
-    const keepChars = opts.maxChars;
-    const headChars = Math.floor(keepChars * 0.5);
-    const tailChars = keepChars - headChars;
-    const head = output.slice(0, headChars);
-    const tail = output.slice(totalChars - tailChars);
-    const omitted = totalChars - keepChars;
-    const marker = `\n[... ${omitted} chars truncated ...]\n`;
-    return { output: head + marker + tail, truncated: true, totalLines, totalChars };
+    return { output: truncateByChars(output), truncated: true, totalLines, totalChars };
 }

package/dist/tools/validate.js

@@ -14,18 +14,20 @@ function validateNode(schema, value, path) {
     if (Object.keys(schema).length === 0)
         return null;
     // anyOf: at least one must pass
+    // 命中不短路：JSON Schema 中 anyOf/oneOf 与 type/required/properties 等
+    // 兄弟关键字是**合取**关系——此前命中即 return null，兄弟校验整体失效
+    // （task 工具 schema 的 properties 类型检查形同虚设：prompt: 123、
+    // tasks 条目缺 assignment 均通过，静默派出 prompt=undefined 的子 agent）。
     if (schema.anyOf) {
         const passed = schema.anyOf.some((s) => validateNode(s, value, path) === null);
         if (!passed)
             return `${path || 'value'}: does not match anyOf schemas`;
-        return null;
     }
     // oneOf: exactly one must pass
     if (schema.oneOf) {
         const count = schema.oneOf.filter((s) => validateNode(s, value, path) === null).length;
         if (count !== 1)
             return `${path || 'value'}: must match exactly one oneOf schema (matched ${count})`;
-        return null;
     }
     // enum
     if (schema.enum !== undefined) {
@@ -40,15 +42,22 @@ function validateNode(schema, value, path) {
             return typeError;
     }
     // object validation
-    if (schema.type === 'object' &&
-        typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value)) {
+    // 结构关键字与 `type` 是**独立**约束：JSON Schema 语义下 required/properties/
+    // additionalProperties 只对「对象实例」生效、items 只对「数组实例」生效，均
+    // 不要求同一节点声明 type。task 工具的 anyOf 分支正是裸 `{required:['prompt']}`
+    // ——此前整个对象校验块以 `schema.type === 'object'` 为前提，这类分支被整体跳过
+    // （二选一守卫形同虚设：`{}`、`{subagent_type:'coder'}` 一律通过校验）。
+    const isObjectValue = typeof value === 'object' && value !== null && !Array.isArray(value);
+    const declaresObjectKeywords = schema.required !== undefined ||
+        schema.properties !== undefined ||
+        schema.additionalProperties !== undefined;
+    if (isObjectValue && declaresObjectKeywords) {
         const obj = value;
-        // required fields
+        // required fields（只认自有属性：`'toString' in {}` 恒真，原型链上的同名键
+        // 不代表实例真的携带该字段）
         if (schema.required) {
             for (const field of schema.required) {
-                if (!(field in obj)) {
+                if (!Object.hasOwn(obj, field)) {
                     return `${path ? `${path}.` : ''}${field}: missing required field`;
                 }
             }
@@ -56,26 +65,61 @@ function validateNode(schema, value, path) {
         // properties
         if (schema.properties) {
             for (const [key, propSchema] of Object.entries(schema.properties)) {
-                if (key in obj) {
+                if (Object.hasOwn(obj, key)) {
                     const err = validateNode(propSchema, obj[key], path ? `${path}.${key}` : key);
                     if (err)
                         return err;
                 }
             }
         }
-        // additionalProperties
-        if (schema.additionalProperties === false && schema.properties) {
-            const knownKeys = new Set(Object.keys(schema.properties));
-            for (const key of Object.keys(obj)) {
-                if (!knownKeys.has(key)) {
-                    return `${path ? `${path}.` : ''}${key}: additional property not allowed`;
+        // additionalProperties 两种形式（JSON Schema draft-07）：
+        //  - false：只允许 properties 声明的键（未声明 properties 时任何键都是额外的）；
+        //  - 模式（{type:'string'} 等）：每个**未被 properties 声明**的键按该模式校验
+        //    （声明键只受自身 schema 约束，不受 additionalProperties 影响）。
+        // 此前只实现 false 分支——声明 additionalProperties:{type:'string'} 的 schema
+        // （bash 工具的 env 等）对未声明键完全放行：env:{FOO:123} 通过校验后进
+        // spawn，值被 Node 静默字符串化（对象变 "[object Object]"）。
+        if (schema.additionalProperties !== undefined) {
+            const knownKeys = new Set(Object.keys(schema.properties ?? {}));
+            if (schema.additionalProperties === false) {
+                for (const key of Object.keys(obj)) {
+                    if (!knownKeys.has(key)) {
+                        return `${path ? `${path}.` : ''}${key}: additional property not allowed`;
+                    }
+                }
+            }
+            else if (typeof schema.additionalProperties === 'object' &&
+                schema.additionalProperties !== null) {
+                for (const [key, value] of Object.entries(obj)) {
+                    if (knownKeys.has(key))
+                        continue;
+                    const err = validateNode(schema.additionalProperties, value, path ? `${path}.${key}` : key);
+                    if (err)
+                        return err;
                 }
             }
         }
     }
-    // array validation
-    if (schema.type === 'array' && Array.isArray(value)) {
-        if (schema.items) {
+    // array validation（items 只对数组实例生效，同样不要求同层 type: 'array'）
+    // minItems/maxItems：数组基数约束（同样只对数组实例生效，与同层 type 无关）。
+    // 此前从未实现——todo 工具 schema 声明的 minItems:1（空阶段不得创建）形同
+    // 虚设：{op:'init', list:[{phase:'P', items:[]}]} 静默通过并持久化空阶段；
+    // MCP 服务器自带的 inputSchema 声明的同类约束同样被静默放行。
+    if (Array.isArray(value) &&
+        (schema.items !== undefined || schema.minItems !== undefined || schema.maxItems !== undefined)) {
+        if (schema.minItems !== undefined) {
+            const minItems = schema.minItems;
+            if (typeof minItems === 'number' && value.length < minItems) {
+                return `${path || 'array'}: expected at least ${minItems} items, got ${value.length}`;
+            }
+        }
+        if (schema.maxItems !== undefined) {
+            const maxItems = schema.maxItems;
+            if (typeof maxItems === 'number' && value.length > maxItems) {
+                return `${path || 'array'}: expected at most ${maxItems} items, got ${value.length}`;
+            }
+        }
+        if (schema.items !== undefined) {
             const itemSchema = Array.isArray(schema.items) ? schema.items : [schema.items];
             for (let i = 0; i < value.length; i++) {
                 const s = itemSchema[i] ?? itemSchema[0];
@@ -97,8 +141,10 @@ function checkType(type, value, path) {
                 return `${label}: expected string, got ${typeof value}`;
             break;
         case 'number':
-            if (typeof value !== 'number' || Number.isNaN(value)) {
-                return `${label}: expected number, got ${typeof value}`;
+            // JSON.parse('1e999') → Infinity 可真实到达（typeof number 且非 NaN），
+            // 放行后进入 slice/setTimeout/max() 等算术即静默错误行为——一律拒绝。
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                return `${label}: expected finite number, got ${typeof value}`;
             }
             break;
         case 'integer':

package/dist/tools/websearch/index.js

@@ -1,4 +1,5 @@
-import { decryptSecret } from '../../core/secret.js';
+import { decryptSecretSafe } from '../../core/secret.js';
+import { headChars } from '../../shared/utils/string.js';
 import { createFetch } from './fetch.js';
 import { braveProvider } from './providers/brave.js';
 import { duckduckgoProvider } from './providers/duckduckgo.js';
@@ -10,9 +11,11 @@ const PROVIDERS = {
     brave: braveProvider,
 };
 /** 环境变量名 → config key 字段映射。环境变量优先于 config。
- *  config 值落盘时已加密（enc: 前缀），此处解密后使用（明文兼容透传）。 */
+ *  config 值落盘时已加密（enc: 前缀），此处解密后使用（明文兼容透传）。
+ *  跨机同步/损坏的密文解密失败 → 视为无 key（undefined）：auto 模式降级
+ *  duckduckgo，显式模式给出「需要 API key」的可操作错误——解密异常不击穿。 */
 function resolveKeys(config) {
-    const decrypt = (v) => (v ? decryptSecret(v) : v);
+    const decrypt = (v) => (v ? decryptSecretSafe(v) : v);
     return {
         tavily: process.env.TAVILY_API_KEY ?? decrypt(config.tavilyApiKey),
         brave: process.env.BRAVE_API_KEY ?? decrypt(config.braveApiKey),
@@ -37,7 +40,8 @@ export function resolveProvider(preference, keys) {
 }
 const SNIPPET_MAX = 240;
 function truncate(text, max) {
-    return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 1))}…`;
+    // headChars 内收切点：截断不产出孤立代理码元
+    return text.length <= max ? text : `${headChars(text, Math.max(0, max - 1))}…`;
 }
 /** 将统一响应格式化为 LLM 友好的纯文本。 */
 export function formatForLLM(response) {

package/dist/update/index.d.ts

@@ -3,7 +3,7 @@ export { confirmHandoff, createHandoffServer, requestHandoff } from './ipc.js';
 export type { UpdateScheduler, UpdateSchedulerOptions } from './scheduler.js';
 export { createUpdateScheduler } from './scheduler.js';
 export type { SerializedEntry, SerializedSession, SessionSnapshot } from './snapshot.js';
-export { orderSessionsByParent, restoreSessions, serializeSessions } from './snapshot.js';
+export { restoreSessions, serializeSessions } from './snapshot.js';
 export type { HotUpdateOptions, HotUpdateResult, InstallMethod, InstallOnlyResult, SpawnFn, } from './updater.js';
 export { cleanupSnapshot, manualInstallCommand, performHandoff, performHotUpdate, performInstall, } from './updater.js';
 export type { UpdateCheckResult } from './version.js';

package/dist/update/index.js

@@ -1,6 +1,6 @@
 // 热更新 + 会话迁移包（spec §18）。
 export { confirmHandoff, createHandoffServer, requestHandoff } from './ipc.js';
 export { createUpdateScheduler } from './scheduler.js';
-export { orderSessionsByParent, restoreSessions, serializeSessions } from './snapshot.js';
+export { restoreSessions, serializeSessions } from './snapshot.js';
 export { cleanupSnapshot, manualInstallCommand, performHandoff, performHotUpdate, performInstall, } from './updater.js';
 export { checkForUpdate, compareSemver, getCurrentVersion } from './version.js';

package/dist/update/scheduler.js

@@ -1,9 +1,16 @@
+import { clampTimerDelay } from '../shared/timer.js';
 import { getCurrentVersion } from './version.js';
 const DEFAULT_INTERVAL_MS = 60 * 60 * 1000;
 const DEFAULT_INITIAL_DELAY_MS = 10_000;
 function createUpdateScheduler(opts) {
-    const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
-    const initialDelayMs = opts.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+    // intervalMs/initialDelayMs 来自用户 config（server.ts 直传），未经校验：
+    // 非有限或超 32 位上限的延迟会被 Node 钳到 1ms——config 里写「超长间隔」
+    // 本意是少检查，实际却以每毫秒一次的频率狂刷 npm registry；写 0/负数
+    // （「不检查」的常见写法）同样落到 1ms 轮询，比超限更糟。一律回落默认值
+    // （超上限钳到上限 ≈ 实践上不再检查，保持既有语义）；0 延迟对
+    // initialDelayMs 合法（立即首检），对周期间隔无意义（回落默认 1 小时）。
+    const intervalMs = clampTimerDelay(opts.intervalMs, DEFAULT_INTERVAL_MS, 1);
+    const initialDelayMs = clampTimerDelay(opts.initialDelayMs, DEFAULT_INITIAL_DELAY_MS, 0);
     // 直接引用全局 timer；vitest useFakeTimers() 会替换全局，start() 时读取即拿到 mock。
     let intervalId = null;
     let initialId = null;

package/dist/update/snapshot.d.ts

@@ -48,11 +48,21 @@ type SessionSnapshot = {
      *  前端持久化布局可无感重连）。旧快照缺省视为无终端。 */
     terminals?: SerializedTerminal[];
 };
-/** 按 parentId 拓扑序排列 sessions，使父会话先于子会话插入（满足自引用 FK）。 */
-declare function orderSessionsByParent(list: SerializedSession[]): SerializedSession[];
 /** 从 DB 导出所有会话与条目为可序列化快照。terminals 为活跃终端元信息（可选）。 */
 declare function serializeSessions(handle: DB, config?: unknown, terminals?: SerializedTerminal[]): Promise<SessionSnapshot>;
-/** 把快照导入 DB（保留原始 id 与时间戳；父会话先插入以满足 FK）。 */
+/**
+ * 把快照导入 DB（保留原始 id 与时间戳），两阶段插入：
+ *  1. 全部会话行以 parentId=NULL 插入——任何插入顺序都满足自引用 FK，
+ *     无需拓扑排序；
+ *  2. 回填各行的 parentId——此时全部行已存在，FK 恒可满足。
+ *
+ * 此前按拓扑序逐个插入（orderSessionsByParent 先父后子）：环防护只保证
+ * 「终止」——parentId 成环（a↔b 互指/自引用）时环上第一个被访问的节点先于
+ * 其父入序，插入它即撞自引用 FK 23503（其父行尚不存在），整个恢复抛错、
+ * serve 启动失败。两阶段插入对任意形状（环/自引用/正常森林）都成立，
+ * 环上节点父指针完整保留；悬空 parentId（快照外引用）在第二阶段撞 FK，
+ * 仍是「数据损坏显式失败」而非静默改写。
+ */
 declare function restoreSessions(handle: DB, snapshot: SessionSnapshot): Promise<void>;
 export type { SerializedEntry, SerializedSession, SerializedTerminal, SessionSnapshot };
-export { orderSessionsByParent, restoreSessions, serializeSessions };
+export { restoreSessions, serializeSessions };