c0de-agent 1.13.1 → 1.14.0

package/dist/cli/commands/serve.js

@@ -21,7 +21,11 @@ async function runServeCommand(ctx) {
     (ctx.banner ?? printStartupBanner)(url);
     // 非回环监听警告：绑定 0.0.0.0/局域网 IP 时本机以外的主机均可访问，
     // 安全性完全依赖 token + allowedOrigins——默认行为已收紧为 127.0.0.1。
-    const isLoopback = host === '127.0.0.1' || host === 'localhost' || host === '::1' || host.startsWith('127.');
+    // 判定必须区分「127. 前缀」与「点分 IPv4 字面量」：host.startsWith('127.')
+    // 会把以 127. 开头的**域名**（127.example.com 等，可解析到任意公网地址）
+    // 误判为回环，非回环绑定的安全警告被静默跳过。仅四段点分十进制且首段为
+    // 127 的串（127.0.0.0/8 全域回环，RFC 1122）算回环。
+    const isLoopback = host === 'localhost' || host === '::1' || /^127(\.\d{1,3}){3}$/.test(host);
     if (!isLoopback) {
         console.warn(`[c0de] ⚠ 监听地址为 ${host}（非回环）：本机以外的主机均可访问此服务。\n` +
             `  请确认 security.authEnabled 已开启、token 未泄漏；仅在可信网络使用，或在防火墙限制访问。`);

package/dist/cli/deps.d.ts

@@ -1,6 +1,6 @@
 import type { LoopDeps } from '../core/loop.js';
+import { buildRegistryFromConfig } from '../core/provider-registry.js';
 import type { DB } from '../db/client.js';
-import type { Registry } from '../llm/registry.js';
 import type { Config } from '../shared/types/config.js';
 import type { PermissionChecker } from '../tools/types.js';
 /** 权限策略：
@@ -11,8 +11,6 @@ type PermissionStrategy = 'full-auto' | 'safe';
 declare const fullyAutoApproveChecker: PermissionChecker;
 /** 无白名单的非交互安全策略（保留导出兼容既有调用方）。 */
 declare const nonInteractiveSafeChecker: PermissionChecker;
-/** 把 config.providers 注册到新建的 LLM registry。 */
-declare function buildLLMRegistry(config: Config): Registry;
 type BuildDepsOptions = {
     db: DB;
     cwd: string;
@@ -32,4 +30,4 @@ declare function resolveCwdProjectTrusted(db: DB, cwd: string): Promise<boolean>
 /** 组装完整 LoopDeps（默认 safe 放行 + 默认工具注册表）。 */
 declare function buildAgentDeps(config: Config, opts: BuildDepsOptions): Promise<LoopDeps>;
 export type { BuildDepsOptions, PermissionStrategy };
-export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, nonInteractiveSafeChecker, resolveCwdProjectTrusted, };
+export { buildAgentDeps, buildRegistryFromConfig, fullyAutoApproveChecker, nonInteractiveSafeChecker, resolveCwdProjectTrusted, };

package/dist/cli/deps.js

@@ -1,6 +1,8 @@
 import { loadConfigScopes } from '../core/config.js';
-import { decryptSecret } from '../core/secret.js';
-import { createRegistry, overrideToCapabilities, registerProvider } from '../llm/index.js';
+import { buildRegistryFromConfig } from '../core/provider-registry.js';
+import { discoverSkills } from '../core/skills.js';
+import { createDebugSpawn } from '../dap/index.js';
+import { collectScopedMCPServers, registerMCPServers } from '../mcp/index.js';
 import { initPlugins } from '../plugins/index.js';
 import { getByDirectory } from '../project/index.js';
 import { projectTrustCurrent } from '../project/trust.js';
@@ -40,31 +42,6 @@ function createNonInteractiveChecker(allowTools) {
 }
 /** 无白名单的非交互安全策略（保留导出兼容既有调用方）。 */
 const nonInteractiveSafeChecker = createNonInteractiveChecker();
-/** 把 config.providers 注册到新建的 LLM registry。 */
-function buildLLMRegistry(config) {
-    const registry = createRegistry();
-    for (const p of config.providers) {
-        registerProviderFromConfig(registry, p);
-    }
-    return registry;
-}
-function registerProviderFromConfig(registry, p) {
-    // 兼容 config.json 中以 _tag 标识 provider 的格式（name 缺失时回退到 _tag）
-    const name = p.name || p._tag;
-    if (!name || !p.baseURL)
-        return;
-    // baseURL 已含 /v1 时用 /chat/completions，避免 /v1/v1 双重前缀
-    const path = p.baseURL.replace(/\/+$/, '').endsWith('/v1') ? '/chat/completions' : undefined;
-    registerProvider(registry, {
-        name,
-        baseURL: p.baseURL,
-        apiKey: p.apiKey ? decryptSecret(p.apiKey) : p.apiKey,
-        ...(path ? { path } : {}),
-        // 传递用户配置的 per-model capabilities（contextWindow 等），
-        // 否则 resolveRoute 回退到 DEFAULT_MODEL_CAPABILITIES，可能导致预算过小。
-        ...(p.models ? { models: overrideToCapabilities(p.models) } : {}),
-    });
-}
 /** 解析权限 checker：显式策略优先，否则回退到 config.permission.defaultMode。
  *  无 --allow 白名单时返回单例 nonInteractiveSafeChecker（保持对象同一性）；有白名单
  *  时按白名单新建 checker（--allow 只影响 ask 工具的定向放行）。 */
@@ -98,39 +75,48 @@ async function resolveCwdProjectTrusted(db, cwd) {
 }
 /** 组装完整 LoopDeps（默认 safe 放行 + 默认工具注册表）。 */
 async function buildAgentDeps(config, opts) {
-    const llmRegistry = buildLLMRegistry(config);
+    const llmRegistry = buildRegistryFromConfig(config);
     const toolRegistry = createDefaultRegistry(config);
     // P0-2：项目插件仅在项目被显式信任后加载（c0de trust <dir>）；内存库
     // （--temp/锁冲突降级）不含项目记录 → 未信任，项目插件不加载。
     // P0（代码面）：已信任但指纹漂移（插件代码/MCP 参数/风险键变更）→ 不加载，
     // 与聊天门禁同口径。
     const projectTrusted = await resolveCwdProjectTrusted(opts.db, opts.cwd);
-    const { hookRunner } = await initPlugins({
+    const { hookRunner, config: resolvedConfig } = await initPlugins({
         cwd: opts.cwd,
         config,
         toolRegistry,
         llmRegistry,
         projectTrusted,
     });
+    // MCP 客户端（spec §6）：全局作用域始终连接；项目作用域（随 git clone 传播的
+    // 任意命令执行面）仅项目已信任时连接——与插件加载同口径。stdio 子进程已
+    // unref：CLI 进程退出时 stdin 关闭，MCP 服务器自行退出。
+    await registerMCPServers(toolRegistry, collectScopedMCPServers(loadConfigScopes(opts.cwd), projectTrusted));
     const deps = {
         db: opts.db,
         llmRegistry,
         toolRegistry,
         urlRegistry: createDefaultURLRegistry(),
         hookRunner,
-        permission: resolvePermissionChecker(config, opts.permissionStrategy, opts.allowTools),
-        config,
+        permission: resolvePermissionChecker(resolvedConfig, opts.permissionStrategy, opts.allowTools),
+        config: resolvedConfig,
         cwd: opts.cwd,
+        // 技能发现（system prompt ## Loaded Skills 段数据源）。
+        skills: discoverSkills(opts.cwd),
+        // DAP（spec §21）：CLI 宿主注入真实适配器 spawn——此前恒报「no debug adapter
+        // spawn is wired」。调试会话随进程结束自然消亡（transport 子进程非 unref）。
+        debugSpawn: createDebugSpawn(),
         ...(opts.chatStream ? { chatStream: opts.chatStream } : {}),
         // P：预算护栏 CLI 变体——print/acp 无恢复 UI，超支中止 run（产出 error）而非
         // 暂停永久挂起。金额与 token 任一动作='pause'/'abort' 即启用（每轮 LLM 请求前检查）。
-        ...(config.usage?.budgetAction === 'pause' ||
-            config.usage?.budgetAction === 'abort' ||
-            config.usage?.tokenBudgetAction === 'pause' ||
-            config.usage?.tokenBudgetAction === 'abort'
+        ...(resolvedConfig.usage?.budgetAction === 'pause' ||
+            resolvedConfig.usage?.budgetAction === 'abort' ||
+            resolvedConfig.usage?.tokenBudgetAction === 'pause' ||
+            resolvedConfig.usage?.tokenBudgetAction === 'abort'
             ? { budgetAbort: true }
             : {}),
     };
     return deps;
 }
-export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, nonInteractiveSafeChecker, resolveCwdProjectTrusted, };
+export { buildAgentDeps, buildRegistryFromConfig, fullyAutoApproveChecker, nonInteractiveSafeChecker, resolveCwdProjectTrusted, };

package/dist/cli/modes/print.js

@@ -99,29 +99,39 @@ async function runPrintMode(config, message, deps, opts = {}) {
     const state = await createAgent(session, agentConfig, deps);
     // P2-4：ACP abort 真中止——把外部信号桥接到该 run 的 abortController。
     // abortAgent 会使 loop 在 turn/流边界 unwind，runAgent 随即结束。
+    // 监听器必须在 run 终结处摘除：{ once: true } 只在「真的触发 abort」时
+    // 自动摘除——正常完成的 run（绝大多数）从不触发 abort，闭包捕获整个
+    // agent state，经 ACP 的 currentAbort（持有上一个 controller）钉住到
+    // 下一次请求才释放（同型：executor/bash/permission checker 口径）。
+    const onAbort = () => {
+        abortAgent(state);
+    };
     if (opts.abortSignal) {
         if (opts.abortSignal.aborted) {
             throw new Error('已中止');
         }
-        opts.abortSignal.addEventListener('abort', () => {
-            abortAgent(state);
-        }, { once: true });
-    }
-    const events = [];
-    for await (const event of runAgent(state, [{ _tag: 'text', text: message }], deps)) {
-        events.push(event);
-        opts.onEvent?.(event);
+        opts.abortSignal.addEventListener('abort', onAbort, { once: true });
     }
-    // P2-4：中止后如实报错（ACP 客户端收到 error 响应，而非谎报 ok 的完成结果）。
-    if (opts.abortSignal?.aborted) {
-        throw new Error('已中止');
+    try {
+        const events = [];
+        for await (const event of runAgent(state, [{ _tag: 'text', text: message }], deps)) {
+            events.push(event);
+            opts.onEvent?.(event);
+        }
+        // P2-4：中止后如实报错（ACP 客户端收到 error 响应，而非谎报 ok 的完成结果）。
+        if (opts.abortSignal?.aborted) {
+            throw new Error('已中止');
+        }
+        // 终态错误（unexpected，含预算中止）必须反馈给用户而非静默返回半截文本——
+        // 抛出后 dispatch 打印 message 并以非零码退出（预算超支中止等硬性护栏由此可见）。
+        const terminal = events.find((e) => e._tag === 'error' && e.error._tag === 'unexpected');
+        if (terminal && terminal._tag === 'error' && terminal.error._tag === 'unexpected') {
+            throw new Error(terminal.error.message);
+        }
+        return collectAssistantText(events);
     }
-    // 终态错误（unexpected，含预算中止）必须反馈给用户而非静默返回半截文本——
-    // 抛出后 dispatch 打印 message 并以非零码退出（预算超支中止等硬性护栏由此可见）。
-    const terminal = events.find((e) => e._tag === 'error' && e.error._tag === 'unexpected');
-    if (terminal && terminal._tag === 'error' && terminal.error._tag === 'unexpected') {
-        throw new Error(terminal.error.message);
+    finally {
+        opts.abortSignal?.removeEventListener('abort', onAbort);
     }
-    return collectAssistantText(events);
 }
 export { collectAssistantText, runPrintMode };

package/dist/core/agent.js

@@ -50,44 +50,67 @@ async function createAgent(session, config, deps) {
     };
 }
 async function* runAgent(state, userInput, deps) {
-    // 幂等重发保护：若 DB 末尾已是相同 user message（服务重启后续传场景），
-    // 跳过 append 避免重复。比较 text/image parts 全量内容——纯文本比较会在
-    // 「含图片消息重发」时误判为不同消息而追加重复条目（P1-2 修复）。
-    const last = state.messages[state.messages.length - 1];
-    const isDupUser = last?.role === 'user' &&
-        last.content.length === userInput.length &&
-        last.content.every((p, i) => {
-            const q = userInput[i];
-            if (p._tag === 'text' && q?._tag === 'text')
-                return p.text === q.text;
-            if (p._tag === 'image' && q?._tag === 'image')
-                return p.mediaType === q.mediaType && p.data === q.data;
-            return false;
-        });
-    if (!isDupUser) {
-        await appendMessage(deps.db, state.session.id, {
-            role: 'user',
-            content: userInput,
-        });
+    // 生命周期 hook（spec §3.7）：agent:start 广播每次 run 的启动配置；
+    // agent:end 无论完成/出错/中止都广播（finally 保证）。
+    // 主 run 与子 agent run 都经此处，插件可按 config.agentName 等区分。
+    if (deps.hookRunner) {
+        try {
+            await deps.hookRunner.fireHooks('agent:start', { config: state.config });
+        }
+        catch {
+            // fireHooks 内部已吞 handler 异常；双保险避免启动广播失败阻断 run
+        }
     }
-    // 标题生成用纯文本（join text parts），忽略 image/tool 等非文本 part。
-    const titleText = userInput
-        .filter((p) => p._tag === 'text')
-        .map((p) => (p._tag === 'text' ? p.text : ''))
-        .join('');
-    // 第一条用户消息后，后台为会话生成简短标题（fire-and-forget）。
-    // 条件：标题仍是默认占位 + 持久化前无任何消息（即首条消息）。
-    // 失败被吞掉，绝不阻塞主对话流。
-    if (state.session.title === DEFAULT_SESSION_TITLE && state.messages.length === 0) {
-        void generateSessionTitle({
-            db: deps.db,
-            llmRegistry: deps.llmRegistry,
-            config: deps.config,
-            ...(deps.titleChatFn ? { chatFn: deps.titleChatFn } : {}),
-        }, state.session.id, titleText, state.config.provider, state.config.model).catch(() => { });
+    try {
+        // 幂等重发保护：若 DB 末尾已是相同 user message（服务重启后续传场景），
+        // 跳过 append 避免重复。比较 text/image parts 全量内容——纯文本比较会在
+        // 「含图片消息重发」时误判为不同消息而追加重复条目（P1-2 修复）。
+        const last = state.messages[state.messages.length - 1];
+        const isDupUser = last?.role === 'user' &&
+            last.content.length === userInput.length &&
+            last.content.every((p, i) => {
+                const q = userInput[i];
+                if (p._tag === 'text' && q?._tag === 'text')
+                    return p.text === q.text;
+                if (p._tag === 'image' && q?._tag === 'image')
+                    return p.mediaType === q.mediaType && p.data === q.data;
+                return false;
+            });
+        if (!isDupUser) {
+            await appendMessage(deps.db, state.session.id, {
+                role: 'user',
+                content: userInput,
+            });
+        }
+        // 标题生成用纯文本（join text parts），忽略 image/tool 等非文本 part。
+        const titleText = userInput
+            .filter((p) => p._tag === 'text')
+            .map((p) => (p._tag === 'text' ? p.text : ''))
+            .join('');
+        // 第一条用户消息后，后台为会话生成简短标题（fire-and-forget）。
+        // 条件：标题仍是默认占位 + 持久化前无任何消息（即首条消息）。
+        // 失败被吞掉，绝不阻塞主对话流。
+        if (state.session.title === DEFAULT_SESSION_TITLE && state.messages.length === 0) {
+            void generateSessionTitle({
+                db: deps.db,
+                llmRegistry: deps.llmRegistry,
+                config: deps.config,
+                ...(deps.titleChatFn ? { chatFn: deps.titleChatFn } : {}),
+            }, state.session.id, titleText, state.config.provider, state.config.model).catch(() => { });
+        }
+        state.status = { _tag: 'running', turnCount: 0 };
+        yield* agentLoop(state, deps);
+    }
+    finally {
+        if (deps.hookRunner) {
+            try {
+                await deps.hookRunner.fireHooks('agent:end', {});
+            }
+            catch {
+                // fireHooks 内部已吞 handler 异常；双保险
+            }
+        }
     }
-    state.status = { _tag: 'running', turnCount: 0 };
-    yield* agentLoop(state, deps);
 }
 function pauseAgent(state, reason) {
     if (state.status._tag !== 'running')

package/dist/core/agents/parallel.js

@@ -19,8 +19,10 @@ async function mapWithConcurrencyLimit(items, concurrency, fn, signal) {
             if (idx >= items.length)
                 return;
             const item = items[idx];
-            if (item === undefined)
-                return;
+            // 退化元素（稀疏数组空洞 / 显式 undefined）是合法入参：照常交给 fn，
+            // 由 fn 决定如何映射——此前遇 undefined 直接 return，该 worker 永久
+            // 退出，并发为 1 时其后全部任务静默跳过（results 留洞，上层把被跳过
+            // 的任务误报为「run aborted 未启动」）。
             results[idx] = await fn(item, idx, workerSignal);
         }
     }

package/dist/core/config-path.d.ts

@@ -1,3 +1,5 @@
+/** 段是否为原型链键（供合并路径跳过自持的 `__proto__` 键）。 */
+declare function isPrototypeKey(key: string): boolean;
 /** 按 a.b.c 点路径从对象取值；找不到抛错。 */
 declare function getByPath(obj: unknown, path: string): unknown;
 /** 按 a.b.c 点路径写值（创建中间对象）。 */
@@ -6,4 +8,4 @@ declare function setByPath(obj: Record<string, unknown>, path: string, value: un
 declare function coerce(value: string): unknown;
 /** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
 declare function setPathPatch(path: string, value: unknown): Record<string, unknown>;
-export { coerce, getByPath, setByPath, setPathPatch };
+export { coerce, getByPath, isPrototypeKey, setByPath, setPathPatch };

package/dist/core/config-path.js

@@ -1,9 +1,28 @@
 // 配置点路径（a.b.c）读写工具：CLI `config set/get` 与斜杠 `/config` 共用。
+/**
+ * 原型链键：`__proto__` / `constructor` / `prototype`。它们不可能是合法配置键
+ * （KNOWN_CONFIG_KEYS 不含），但点路径（用户/模型可控：`/config` 斜杠命令对点路径
+ * 无顶层键校验）与 JSON 配置文件键都可能携带，经普通赋值即改写原型链：
+ * setByPath 沿 `__proto__` 段继续下钻拿到的是 Object.prototype，末段直接写进
+ * 全局原型——进程内所有对象/数组凭空多出该属性（回显「已设置」，JSON.stringify
+ * 落盘时又静默丢弃）。写入/读取一律显式拒绝。
+ */
+const PROTOTYPE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/** 段是否为原型链键（供合并路径跳过自持的 `__proto__` 键）。 */
+function isPrototypeKey(key) {
+    return PROTOTYPE_KEYS.has(key);
+}
+function assertNoPrototypeKey(path, segment) {
+    if (isPrototypeKey(segment)) {
+        throw new Error(`config: 键路径 "${path}" 含原型链段 "${segment}"——该段会改写原型链而非写入配置，已拒绝`);
+    }
+}
 /** 按 a.b.c 点路径从对象取值；找不到抛错。 */
 function getByPath(obj, path) {
     const parts = path.split('.');
     let cur = obj;
     for (const p of parts) {
+        assertNoPrototypeKey(path, p);
         if (cur === null || typeof cur !== 'object')
             throw new Error(`config: key "${path}" not found`);
         cur = cur[p];
@@ -18,11 +37,14 @@ function setByPath(obj, path, value) {
     let cur = obj;
     for (let i = 0; i < parts.length - 1; i++) {
         const k = parts[i];
+        assertNoPrototypeKey(path, k);
         const next = cur[k];
         cur[k] = (next !== null && typeof next === 'object' ? next : {});
         cur = cur[k];
     }
-    cur[parts[parts.length - 1]] = value;
+    const leaf = parts[parts.length - 1];
+    assertNoPrototypeKey(path, leaf);
+    cur[leaf] = value;
 }
 /** 把字符串解析为合适的标量类型。 */
 function coerce(value) {
@@ -32,12 +54,20 @@ function coerce(value) {
         return false;
     if (/^-?\d+(\.\d+)?$/.test(value))
         return Number(value);
+    let parsed;
     try {
-        return JSON.parse(value);
+        parsed = JSON.parse(value);
     }
     catch {
         return value;
     }
+    // JSON 数值文法允许 1e999——解析为 Infinity，JSON.stringify 落盘为 null：
+    // 「设置超大预算/超长间隔」变成「静默删除该键」（预算护栏关闭）。
+    // 显式拒绝，让 CLI /config 斜杠命令把错误反馈给用户/模型。
+    if (typeof parsed === 'number' && !Number.isFinite(parsed)) {
+        throw new Error(`config: 值 "${value}" 是非有限数值（JSON 无法表示，拒绝写入）`);
+    }
+    return parsed;
 }
 /** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
 function setPathPatch(path, value) {
@@ -45,4 +75,4 @@ function setPathPatch(path, value) {
     setByPath(root, path, value);
     return root;
 }
-export { coerce, getByPath, setByPath, setPathPatch };
+export { coerce, getByPath, isPrototypeKey, setByPath, setPathPatch };

package/dist/core/config.js

@@ -1,6 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, join, resolve } from 'node:path';
+import { isPrototypeKey } from './config-path.js';
 import { encryptSecret, isEncryptedSecret } from './secret.js';
 const GLOBAL_CONFIG_DIR = '.c0de';
 const CONFIG_FILENAME = 'config.json';
@@ -58,6 +59,10 @@ function mergeConfig(...configs) {
         if (!cfg)
             continue;
         for (const key of Object.keys(cfg)) {
+            // 自持的原型链键（配置文件里手写/克隆仓库自带的 `"__proto__"`）：赋值会改写
+            // 合并结果的原型而非写入键——合并视图凭空多出继承属性，且不可枚举/不可落盘。
+            if (isPrototypeKey(key))
+                continue;
             const val = cfg[key];
             if (val === undefined)
                 continue;
@@ -179,6 +184,68 @@ function loadConfigScopes(projectDir) {
         project: stripProjectServerKeys(readJsonIfExists(projectPath)),
     };
 }
+/**
+ * 递归断言 patch 树中不含非有限数值。JSON 数值文法允许 1e999/1e309——
+ * JSON.parse 解析为 ±Infinity，JSON.stringify 落盘为 null：写入通道回显
+ * 「已设置」，实际键被静默删除（预算护栏等安全相关键尤其致命）。
+ * 三个写入入口（CLI config set、/config 斜杠、REST PATCH）共用本检查，
+ * 抛错由各入口转成面向用户/模型的明确错误。
+ */
+function assertFiniteNumbers(value, path) {
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new Error(`${path} 含非有限数值 ${value}（JSON 无法表示，拒绝写入）`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            assertFiniteNumbers(value[i], `${path}[${i}]`);
+        }
+        return;
+    }
+    if (value !== null && typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            assertFiniteNumbers(v, `${path}.${k}`);
+        }
+    }
+}
+/**
+ * 校验 providers 列表条目形状。providers 是配置写入的唯一「对象数组」字段，
+ * 三个写入入口（CLI config set、/config 斜杠、REST PATCH）都经 applyScopedPatch
+ * 汇聚——畸形条目此前被原样落盘/透传：
+ *  - null 条目：REST PATCH 的 apiKey 加密映射处 TypeError 500；已落盘的 null
+ *    随后让 registry 重建（启动/同步）读 p.name 抛 TypeError，服务无法启动。
+ *  - 字符串条目：静默持久化成毒化配置，registry 构建时被跳过——UI 显示已保存，
+ *    provider 永不可用。
+ *  - baseURL/apiKey 非字符串：registerProviderFromConfig 对 baseURL 调
+ *    .replace/.endsWith 抛 TypeError（同步 registry 或下次启动击穿）。
+ * 显式拒绝，错误含条目下标供调用方定位。name 兼容注册表读取侧的 _tag 回退
+ * （旧版 config.json 格式），但两者都缺则拒绝。
+ */
+function assertValidProviderList(value, path) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${path} 必须是 provider 对象数组（${JSON.stringify(value)}）`);
+    }
+    for (let i = 0; i < value.length; i++) {
+        const p = value[i];
+        if (p === null || typeof p !== 'object' || Array.isArray(p)) {
+            throw new Error(`${path}[${i}] 必须是 provider 对象（收到 ${JSON.stringify(p)}）`);
+        }
+        const e = p;
+        const name = typeof e.name === 'string' && e.name.length > 0 ? e.name : undefined;
+        const tag = typeof e._tag === 'string' && e._tag.length > 0 ? e._tag : undefined;
+        if (name === undefined && tag === undefined) {
+            throw new Error(`${path}[${i}] 缺少非空字符串 name（收到 ${JSON.stringify(p)}）`);
+        }
+        if (e.baseURL !== undefined && typeof e.baseURL !== 'string') {
+            throw new Error(`${path}[${i}].baseURL 必须是字符串（收到 ${JSON.stringify(e.baseURL)}）`);
+        }
+        if (e.apiKey !== undefined && typeof e.apiKey !== 'string') {
+            throw new Error(`${path}[${i}].apiKey 必须是字符串（收到 ${JSON.stringify(e.apiKey)}）`);
+        }
+    }
+}
 /**
  * 把 patch 应用到某个作用域的原始配置（scoped patch，null=删除）：
  * - 深合并：嵌套普通对象递归合并，数组整体替换（providers 等列表语义）；
@@ -188,14 +255,23 @@ function loadConfigScopes(projectDir) {
  * 不注入默认值。CLI config set / 服务端 PATCH /api/config 共用。
  */
 function applyScopedPatch(base, patch) {
+    assertFiniteNumbers(patch, 'config');
     const result = { ...(base ?? {}) };
     for (const [key, val] of Object.entries(patch)) {
+        // 自持的原型链键（JSON.parse 的 `"__proto__"` 会建成自有键）经普通赋值改写
+        // result 的原型而非写入键：配置读起来像「没写」，键又被静默丢弃。跳过。
+        if (isPrototypeKey(key))
+            continue;
         if (val === undefined)
             continue;
         if (val === null) {
             delete result[key];
             continue;
         }
+        // providers 条目形状校验（唯一对象数组字段；畸形条目落盘即毒化配置）。
+        if (key === 'providers') {
+            assertValidProviderList(val, 'config.providers');
+        }
         const current = result[key];
         if (typeof val === 'object' &&
             !Array.isArray(val) &&
@@ -221,6 +297,8 @@ function mergeRaw(...cfgs) {
         if (!cfg)
             continue;
         for (const [key, val] of Object.entries(cfg)) {
+            if (isPrototypeKey(key))
+                continue;
             if (val === undefined)
                 continue;
             const current = result[key];
@@ -263,6 +341,9 @@ async function saveConfigScoped(scope, projectDir, data) {
 function redactSensitiveOnSave(data) {
     const out = {};
     for (const [key, val] of Object.entries(data)) {
+        // 原型链键不落盘（赋值会改写 out 的原型，键本身也不会被序列化）。
+        if (isPrototypeKey(key))
+            continue;
         if (key === 'providers' && Array.isArray(val)) {
             out[key] = val.map((p) => {
                 if (p === null || typeof p !== 'object')

package/dist/core/context.js

@@ -1,4 +1,4 @@
-import { estimateTokens } from '../session/token.js';
+import { estimateMessageTokens } from '../session/token.js';
 // Token 预算分配（spec §3.6 策略1）：
 //   reserved       20% — system prompt + 工具描述
 //   historyBudget  60% — 历史消息上限
@@ -21,11 +21,14 @@ function createTokenBudget(totalTokens, opts) {
         keepRecent: opts?.keepRecent ?? Math.floor(totalTokens * KEEP_RECENT_RATIO),
     };
 }
-/** 单条消息的原始 token 估算（不应用校准系数）。 */
+/** 单条消息的原始 token 估算（不应用校准系数）。
+ *  全 content 部分口径（text/thinking/steering/tool_call/tool_result）——
+ *  此前只统计 text/thinking，纯工具消息按 0 token 计、预算与压缩判定脱节；
+ *  与 compaction 的 messageTokens（estimateMessageTokens）同源同口径。 */
 function rawMessageTokens(m) {
     if (m.tokenCount > 0)
         return m.tokenCount;
-    return estimateTokens(m.content.map((p) => (p._tag === 'text' || p._tag === 'thinking' ? p.text : '')).join(''));
+    return estimateMessageTokens(m.content);
 }
 function estimateBudget(messages, factor = 1.0) {
     const raw = messages.reduce((sum, m) => sum + rawMessageTokens(m), 0);

package/dist/core/loop/persist.js

@@ -2,7 +2,7 @@ import { createKanbanStore } from '../../kanban/index.js';
 import { appendMessage } from '../../session/message.js';
 import { inferToolMode, recordToolMetrics } from '../metrics.js';
 import { executeToolCalls } from '../tool-exec.js';
-import { runSubAgent } from './subagent.js';
+import { runSubAgent, runSubAgents } from './subagent.js';
 function toolResultToContent(toolCallId, toolName, result) {
     return [{ _tag: 'tool_result', id: toolCallId, tool: toolName, output: result }];
 }
@@ -64,6 +64,9 @@ export async function* persistAssistantAndTools(state, deps, collectedText, vali
             ...(deps.urlRegistry ? { urlRegistry: deps.urlRegistry } : {}),
             ...(deps.debugSpawn ? { debugSpawn: deps.debugSpawn } : {}),
             runSubAgent: (req) => runSubAgent({ ...deps, _subagentEventSink: eventSink }, state, req),
+            // task 工具批量模式：宿主批量入口按 config.agents.subagentConcurrency 建并发池
+            // （与工作流 ctx.runSubagents 共用同一实现），子 agent 事件同走 eventSink。
+            runSubAgents: (reqs) => runSubAgents({ ...deps, _subagentEventSink: eventSink }, state, reqs),
             ...(deps._subagentYieldCollector ? { collectYield: deps._subagentYieldCollector } : {}),
             // todo 工具状态通过 dependency-reversal hook 注入：get/set 直接读写
             // state.todoPhases（in-memory），tool result 的 metadata.phases 充当

package/dist/core/loop/subagent.d.ts

@@ -10,3 +10,22 @@ import type { LoopDeps } from '../loop.js';
  *  def.isolated 时在 git worktree 中运行，结束后把 delta 自动 apply 回父仓库（spec §4.6）。
  *  request.background 时 fork 异步运行，立即返回 running（spec §4.7）。 */
 export declare function runSubAgent(deps: LoopDeps, parent: AgentState, request: SubAgentRequest): Promise<SubAgentResult>;
+/** 归一化子 agent 并发上限：缺失/非有限/<1 回落默认 3，上限钳到 10。
+ *  与 ToolDef.timeout / clampTimerDelay 同口径——配置面的退化值不得让派发失控
+ *  （0 或负数会让并发池退化成「一个都不跑」）。 */
+export declare function normalizeSubagentConcurrency(value: number | undefined): number;
+/** 单任务派发函数（批量派发的注入点：工作流宿主自带 runner 时无需经 deps 组装）。 */
+type SubAgentRunner = (request: SubAgentRequest) => Promise<SubAgentResult>;
+/**
+ * 批量派发子 agent（task 工具批量模式 / 工作流 ctx.runSubagents 共用）。
+ *
+ * - 并发上限取 config.agents.subagentConcurrency（默认 3）——此前 task 工具批量模式
+ *   逐个 await（墙钟时间线性叠加，与工具描述的 "Launch multiple agents concurrently"
+ *   相悖），工作流侧则硬编码 3（配置项形同虚设）。
+ * - 结果与入参顺序一一对应，绝不出现空洞：未启动的任务（abort）填 error 结果，
+ *   调用方无需再处理 undefined。
+ * - 单个任务失败隔离（抛错/error 结果都收敛为 error），不 fail-fast 终止兄弟任务。
+ * - abort（父 run 中止）取消尚未启动的任务。
+ */
+export declare function runSubAgents(deps: LoopDeps, parent: AgentState, requests: SubAgentRequest[], runOne?: SubAgentRunner): Promise<SubAgentResult[]>;
+export {};