c0de-agent 1.13.0 → 1.14.0

package/dist/core/loop/subagent.js

@@ -1,7 +1,10 @@
 import { appendMessage } from '../../session/message.js';
 import { createSession, updateSessionLastRun } from '../../session/session.js';
 import { generateId } from '../../shared/index.js';
-import { createAgent, runAgent } from '../agent.js';
+import { headChars } from '../../shared/utils/string.js';
+import { validateInput } from '../../tools/validate.js';
+import { abortAgent, createAgent, runAgent } from '../agent.js';
+import { mapWithConcurrencyLimit } from '../agents/parallel.js';
 import { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree, } from '../worktree.js';
 /** 运行一个按类型派发的子 agent（spec: multi-agent-design §4.5）。
  *
@@ -24,7 +27,7 @@ export async function runSubAgent(deps, parent, request) {
         };
     }
     const title = request.description?.trim() ||
-        `Sub-agent (${request.agentType}): ${request.prompt.slice(0, 60)}`;
+        `Sub-agent (${request.agentType}): ${headChars(request.prompt, 60)}`;
     const childId = generateId();
     const yielded = [];
     // 发射 subagent_start 事件（spec §4.5 step 7）
@@ -39,7 +42,7 @@ export async function runSubAgent(deps, parent, request) {
     //    删除父会话时级联，不再是游离根节点）
     let childSession;
     try {
-        childSession = await createSession(deps.db, title, parent.session.projectId ?? undefined, request.agentType, parent.session.source ?? undefined, parent.session.id);
+        childSession = await createSession(deps.db, title, parent.session.projectId ?? undefined, request.agentType, parent.session.source ?? undefined, parent.session.id, undefined, undefined, deps.hookRunner);
     }
     catch (e) {
         return { _tag: 'error', error: e instanceof Error ? e.message : String(e) };
@@ -81,11 +84,21 @@ export async function runSubAgent(deps, parent, request) {
         ...(def.model ? { model: def.model } : {}),
         ...(request.model ? { model: request.model } : {}),
     };
-    // 子 agent 的 deps：覆盖 cwd（worktree）+ 注入 yield 收集器 + 递归深度
+    // 子 agent 的 deps：覆盖 cwd（worktree）+ 注入 yield 收集器 + 递归深度。
+    // yield 收集器对 def.outputSchema 做 JSON Schema 校验（spec: multi-agent-design
+    // §4.5 声明但从未消费）：不合法抛错 → yield 工具折成 error 反馈给模型，模型可
+    // 修正后重试；合法才入收集数组（最终作为 task 结果 data 回传父 agent）。
     const childDeps = {
         ...deps,
         cwd: childCwd,
         _subagentYieldCollector: (data) => {
+            if (def.outputSchema) {
+                const result = validateInput(def.outputSchema, data);
+                if (!result.valid) {
+                    throw new Error(`yield data does not match the agent's outputSchema: ${result.error}. ` +
+                        'Call yield again with data that satisfies the schema.');
+                }
+            }
             yielded.push(data);
         },
         _subagentDepth: childDepth,
@@ -95,12 +108,21 @@ export async function runSubAgent(deps, parent, request) {
     // 继续后，子 agent 不应再因同一预算超支提前中止（用户已知情继续）；父未超支
     // 时标记为 undefined，子 agent 自跑其 loop 仍会按轮次独立检查预算。
     childState.budgetPauseTriggered = parent.budgetPauseTriggered;
-    // abort 链接：父 abort 则子 abort
+    // abort 链接：父 abort 则子 abort。
+    // 必须走 abortAgent（= abort signal + 把 running/paused 清成 stopped）而非裸
+    // abortController.abort()：子 run 可能正停在暂停点（权限超时/预算暂停会级联暂停
+    // 子 run），signal-only 中止不清 status，子 loop 的暂停等待永远不返回——子 run
+    // 槽位泄漏、父 run 的工具批次（task 工具 await）永不返回。
+    // 监听器在子 run 结束时摘除（见 runBody 的 finally）：{ once: true } 只在真的
+    // 触发 abort 时自动摘除，正常完成的子 run（绝大多数）从不触发——父 run 级
+    // signal 上每派发一个子 agent 就留一个监听器，累积到 11 个即触发 Node 的
+    // MaxListenersExceededWarning，闭包也随 signal 活到父 run 结束。
+    const onParentAbort = () => abortAgent(childState);
     if (parent.abortController.signal.aborted) {
-        childState.abortController.abort();
+        abortAgent(childState);
     }
     else {
-        parent.abortController.signal.addEventListener('abort', () => childState.abortController.abort(), { once: true });
+        parent.abortController.signal.addEventListener('abort', onParentAbort, { once: true });
     }
     // P1：把子 run（同步 + 后台）注册进宿主 run 跟踪器（Web=agentManager）。
     // 此前子 run 完全游离：暂停（权限超时/用户/预算）、热更新 pauseAll、
@@ -120,6 +142,9 @@ export async function runSubAgent(deps, parent, request) {
             return await runChildBody(childState, childDeps, childSession, title, baseline, worktreePath);
         }
         finally {
+            // 子 run 结束即摘除父 signal 上的 abort 联动监听器（background 路径在此前
+            // 一直保留——子 run 仍在跑时父 abort 必须仍能级联，故只能在此摘除）。
+            parent.abortController.signal.removeEventListener('abort', onParentAbort);
             unregisterChild?.();
         }
     };
@@ -220,3 +245,44 @@ export async function runSubAgent(deps, parent, request) {
     }
     return runBody();
 }
+/** 子 agent 并发上限的默认值与上限。
+ *  配置项 config.agents.subagentConcurrency 经 normalizeSubagentConcurrency 归一化；
+ *  上限 10 防配置面（手改/克隆仓库自带）把并发推到宿主无法承受（每个子 agent 都是
+ *  独立 session + LLM 调用 + DB 写）。 */
+const DEFAULT_SUBAGENT_CONCURRENCY = 3;
+const MAX_SUBAGENT_CONCURRENCY = 10;
+/** 归一化子 agent 并发上限：缺失/非有限/<1 回落默认 3，上限钳到 10。
+ *  与 ToolDef.timeout / clampTimerDelay 同口径——配置面的退化值不得让派发失控
+ *  （0 或负数会让并发池退化成「一个都不跑」）。 */
+export function normalizeSubagentConcurrency(value) {
+    if (value === undefined || !Number.isFinite(value) || value < 1) {
+        return DEFAULT_SUBAGENT_CONCURRENCY;
+    }
+    return Math.min(Math.trunc(value), MAX_SUBAGENT_CONCURRENCY);
+}
+/**
+ * 批量派发子 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 async function runSubAgents(deps, parent, requests, runOne = (request) => runSubAgent(deps, parent, request)) {
+    if (requests.length === 0)
+        return [];
+    const limit = normalizeSubagentConcurrency(deps.config.agents?.subagentConcurrency);
+    const { results } = await mapWithConcurrencyLimit(requests, limit, async (request) => {
+        try {
+            return await runOne(request);
+        }
+        catch (e) {
+            // 隔离单个任务的异常：不向上抛，避免 fail-fast 终止尚未启动的兄弟任务
+            return { _tag: 'error', error: e instanceof Error ? e.message : String(e) };
+        }
+    }, parent.abortController.signal);
+    return results.map((result, i) => result ?? { _tag: 'error', error: `sub-agent task ${i + 1} was not started (run aborted)` });
+}

package/dist/core/loop.d.ts

@@ -2,7 +2,7 @@ import { chatStream as llmChatStream } from '../llm/provider.js';
 import type { AgentEvent, AgentState } from '../shared/types/agent.js';
 import type { AgentDependencies } from './types.js';
 export { compactContext } from './loop/compaction.js';
-export { runSubAgent } from './loop/subagent.js';
+export { runSubAgent, runSubAgents } from './loop/subagent.js';
 type LoopDeps = AgentDependencies & {
     chatStream?: typeof llmChatStream;
     /** 子 agent 运行时注入：yield 工具的结果收集器（透传到 ToolContext.collectYield）。 */
@@ -19,6 +19,9 @@ type LoopDeps = AgentDependencies & {
     /** 预算护栏的 CLI 变体：无恢复 UI，超支时**中止 run**并产出 error（而非暂停挂起）。
      *  由 CLI deps 组装（buildAgentDeps）按 usage 动作注入，替代 budgetPause（恒 abort）。 */
     readonly budgetAbort?: boolean;
+    /** 已发现技能名列表（src/core/skills.ts discoverSkills）→ PromptContext.skills →
+     *  system prompt ## Loaded Skills 段。宿主（CLI/Web 各通道）注入；未注入时为空。 */
+    readonly skills?: string[];
 };
 export type { LoopDeps };
 export declare function agentLoop(state: AgentState, deps: LoopDeps): AsyncGenerator<AgentEvent>;

package/dist/core/loop.js

@@ -16,7 +16,7 @@ import { DEFAULT_EDIT_MODE, getToolMetrics, selectBestMode } from './metrics.js'
 import { buildDynamicPrompt, createPromptRegistry, registerPromptSection, } from './prompt-registry.js';
 import { drainSteering } from './steering.js';
 export { compactContext } from './loop/compaction.js';
-export { runSubAgent } from './loop/subagent.js';
+export { runSubAgent, runSubAgents } from './loop/subagent.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** provider 未声明 contextWindow 时回填的保守下限（避免估计过大不压缩、过小过度压缩）。 */
 const FALLBACK_CONTEXT_WINDOW = 32_000;
@@ -53,8 +53,16 @@ function resolveEffectiveContextWindow(state, raw, inputTokens, provider, model)
     effectiveContextWindowCache.set(state, estimated);
     return estimated;
 }
+/**
+ * 等待 resume（或 abort）。暂停态只由 status 表达，但 abort 路径不止一条：
+ * `abortAgent` 会同时置 stopped，而父→子 abort 联动等 signal-only 路径不会——
+ * 只查 status 会让暂停中的 run 在 100ms 空转里永久等待（run 槽位不释放、父 run
+ * 的工具批次永不返回、会话 409 RUN_ACTIVE 锁死）。故 signal 中止同样结束等待，
+ * 由调用方按「仍是 paused」判定为中止退出。
+ */
 async function waitForResume(state) {
-    while (true) {
+    const signal = state.abortController.signal;
+    while (!signal.aborted) {
         await sleep(100);
         if (state.status._tag !== 'paused')
             return;
@@ -85,8 +93,13 @@ export async function* agentLoop(state, deps) {
                 startedAt: state.lastRunStartedAt ?? Date.now(),
             }).catch(() => { });
             await waitForResume(state);
-            if (state.status._tag === 'paused')
-                return; // 等待期间被 abort 等终结
+            // 等待期间被中止（abortAgent 置 stopped / signal-only 中止仍是 paused）
+            // 一律结束本 run：继续往下会把状态复位成 running 并再发一次 LLM 请求，
+            // 已中止的 run 复活成「运行中」。状态经显式断言重新读取——上方 if 的
+            // paused 收窄在 await 后仍生效，直接比较会被 TS 判为无交集。
+            const afterWait = state.status;
+            if (afterWait._tag !== 'running')
+                return;
         }
         // 预算护栏：金额 + token 双口径（token 兜底价格未知的自建网关/未登记模型），
         // 每轮 LLM 请求前检查。每 run 至多触发一次（budgetPauseTriggered），恢复后
@@ -125,7 +138,10 @@ export async function* agentLoop(state, deps) {
                         // budgetPauseTriggered，避免同一超支原因二次暂停打断用户。
                         await markBudgetPause(deps.db, state.session.id, reason).catch(() => { });
                         await waitForResume(state);
-                        if (state.status._tag === 'paused')
+                        // 同暂停点：等待期间被中止（stopped）或 signal-only 中止（仍 paused）
+                        // 一律结束本 run，绝不把已中止的 run 复位成 running 再发 LLM 请求。
+                        const afterBudgetWait = state.status;
+                        if (afterBudgetWait._tag !== 'running')
                             return;
                     }
                     else {
@@ -203,7 +219,7 @@ export async function* agentLoop(state, deps) {
             tools: state.tools,
             config: state.config,
             projectInfo: detectProjectInfo(deps.cwd),
-            skills: [],
+            skills: deps.skills ?? [],
         };
         // spec §16.5：edit 工具模式偏好。仅当该轮启用 edit 且某模式历史成功率
         // 显著优于默认时，向 system prompt 追加偏好提示，引导模型选择高成功率模式。

package/dist/{server/registry-config.d.ts → core/provider-registry.d.ts}

@@ -1,9 +1,17 @@
 import { type Registry } from '../llm/registry.js';
 import type { Config } from '../shared/types/config.js';
 import type { ProviderConfig } from '../shared/types/llm.js';
-/** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
-declare function buildRegistryFromConfig(config: Config): Registry;
+/** 注册单个 provider 配置条目（畸形/不可解条目静默跳过，绝不抛错）。
+ *
+ * 跳过而非击穿的理由：
+ *  - 手改/旧版配置文件可能携带畸形条目（null/字符串/数组等）：读取侧自愈兜底，
+ *    否则保存接口 500（syncRegistryFromConfig）或服务/CLI 无法启动。
+ *  - 机器绑定密文换机后不可解（enc: 前缀的 apiKey 跨机同步/容器重建）：跳过该
+ *    provider 并告警，而非上抛击穿启动/请求路径——密文本就不可跨机解密。
+ */
 declare function registerProviderFromConfig(registry: Registry, p: ProviderConfig): void;
+/** 把 config.providers 注册到新建的 LLM registry（server 启动与 CLI deps 共用）。 */
+declare function buildRegistryFromConfig(config: Config): Registry;
 /**
  * config 变更后原子地同步 registry：在隔离的 next registry 上重建全部路由，
  * 完成后一次性替换 registry 内部 table 引用。运行中的 resolveRoute 任何时刻

package/dist/core/provider-registry.js

@@ -0,0 +1,66 @@
+// config.providers ↔ LLM registry 的构建/同步逻辑（单一权威实现）。
+//
+// 此前 server/registry-config.ts 与 cli/deps.ts 各持一份 registerProviderFromConfig：
+// server 版带「畸形条目跳过」守卫（读取侧自愈兜底），CLI 版没有——手改/旧版
+// config.json 里的畸形条目（null 条目、baseURL 非字符串）在 CLI 路径上让
+// `p.name` / `p.baseURL.replace` 抛 TypeError，而 buildAgentDeps 无 try/catch：
+// c0de chat / print / acp 启动即崩溃（server 路径因守卫而幸免）。
+// 收敛到本模块：server 路由 / CLI deps 共用同一实现，杜绝再次漂移。
+import { createRegistry, overrideToCapabilities, rebuildRegistry, registerProvider, } from '../llm/registry.js';
+import { decryptSecretSafe } from './secret.js';
+/** 注册单个 provider 配置条目（畸形/不可解条目静默跳过，绝不抛错）。
+ *
+ * 跳过而非击穿的理由：
+ *  - 手改/旧版配置文件可能携带畸形条目（null/字符串/数组等）：读取侧自愈兜底，
+ *    否则保存接口 500（syncRegistryFromConfig）或服务/CLI 无法启动。
+ *  - 机器绑定密文换机后不可解（enc: 前缀的 apiKey 跨机同步/容器重建）：跳过该
+ *    provider 并告警，而非上抛击穿启动/请求路径——密文本就不可跨机解密。
+ */
+function registerProviderFromConfig(registry, p) {
+    // 写入侧（applyScopedPatch 的 assertValidProviderList）已显式拒绝畸形条目，
+    // 此处是读取侧的自愈兜底。
+    if (p === null || typeof p !== 'object' || Array.isArray(p))
+        return;
+    // 兼容 config.json 中以 _tag 标识 provider 的格式（name 缺失时回退到 _tag）
+    const name = p.name || p._tag;
+    if (!name || typeof p.baseURL !== 'string' || !p.baseURL)
+        return;
+    const apiKey = typeof p.apiKey === 'string' && p.apiKey ? decryptSecretSafe(p.apiKey) : p.apiKey;
+    if (p.apiKey && apiKey === undefined) {
+        console.warn(`provider "${name}" 的 apiKey 无法在本机解密（配置来自其他机器或密文损坏），已跳过注册，请重新设置`);
+        return;
+    }
+    // baseURL 已含 /v1 时用 /chat/completions，避免 /v1/v1 双重前缀
+    const path = p.baseURL.replace(/\/+$/, '').endsWith('/v1') ? '/chat/completions' : undefined;
+    registerProvider(registry, {
+        name,
+        baseURL: p.baseURL,
+        apiKey: apiKey ?? p.apiKey ?? '',
+        ...(path ? { path } : {}),
+        // 传递用户配置的 per-model capabilities（contextWindow 等），
+        // 否则 resolveRoute 回退到 DEFAULT_MODEL_CAPABILITIES，可能导致预算过小。
+        ...(p.models ? { models: overrideToCapabilities(p.models) } : {}),
+    });
+}
+/** 把 config.providers 注册到新建的 LLM registry（server 启动与 CLI deps 共用）。 */
+function buildRegistryFromConfig(config) {
+    const registry = createRegistry();
+    for (const p of config.providers) {
+        registerProviderFromConfig(registry, p);
+    }
+    return registry;
+}
+/**
+ * config 变更后原子地同步 registry：在隔离的 next registry 上重建全部路由，
+ * 完成后一次性替换 registry 内部 table 引用。运行中的 resolveRoute 任何时刻
+ * 看到的都是完整的旧表或完整的新表，不会读到「已清空但未注册完」的半状态，
+ * 因此不会把本可用的 provider 误判为 NoRoute。ServerContext 立即生效，无需重启。
+ */
+function syncRegistryFromConfig(registry, config) {
+    rebuildRegistry(registry, (next) => {
+        for (const p of config.providers) {
+            registerProviderFromConfig(next, p);
+        }
+    });
+}
+export { buildRegistryFromConfig, registerProviderFromConfig, syncRegistryFromConfig };

package/dist/core/redact.d.ts

@@ -3,7 +3,8 @@
  * 防止 apiKey / token 等明文出现在聊天界面或终端输出中。
  */
 export declare function isSecretKey(key: string): boolean;
-/** 掩码敏感值：短值整体掩码；长值保留首尾各 4 位。非字符串统一返回 ****。 */
+/** 掩码敏感值：短值整体掩码；长值保留首尾各 4 位。非字符串统一返回 ****。
+ *  首尾切点经 headChars/tailChars 内收，绝不产出孤立代理码元。 */
 export declare function maskSecret(value: unknown): unknown;
 /** 递归脱敏：键名命中敏感模式的字段被掩码，其余结构原样保留。 */
 export declare function redactSecrets(value: unknown, key?: string): unknown;

package/dist/core/redact.js

@@ -2,18 +2,20 @@
  * 敏感字段脱敏工具：/config 斜杠命令与 `c0de config get` 展示配置时使用，
  * 防止 apiKey / token 等明文出现在聊天界面或终端输出中。
  */
+import { headChars, tailChars } from '../shared/utils/string.js';
 /** 敏感字段名模式（大小写不敏感，匹配完整键名）。 */
 const SECRET_KEY_RE = /(api[_-]?key|token|password|passwd|secret|authorization|auth[_-]?token)$/i;
 export function isSecretKey(key) {
     return SECRET_KEY_RE.test(key);
 }
-/** 掩码敏感值：短值整体掩码；长值保留首尾各 4 位。非字符串统一返回 ****。 */
+/** 掩码敏感值：短值整体掩码；长值保留首尾各 4 位。非字符串统一返回 ****。
+ *  首尾切点经 headChars/tailChars 内收，绝不产出孤立代理码元。 */
 export function maskSecret(value) {
     if (typeof value !== 'string')
         return '****';
     if (value.length <= 8)
         return '****';
-    return `${value.slice(0, 4)}****${value.slice(-4)}`;
+    return `${headChars(value, 4)}****${tailChars(value, 4)}`;
 }
 /** 递归脱敏：键名命中敏感模式的字段被掩码，其余结构原样保留。 */
 export function redactSecrets(value, key) {

package/dist/core/secret.d.ts

@@ -10,3 +10,8 @@ export declare function encryptSecret(plaintext: string): string;
  * 解密存储值。带 `enc:` 前缀则解密；否则原样返回（明文兼容，平滑迁移）。
  */
 export declare function decryptSecret(stored: string): string;
+/** 解密存储值；失败（机器绑定密钥换机/密文损坏）返回 undefined 而非上抛。
+ *  机器绑定意味着密文不可跨机器解密——跨机同步配置（dotfiles/git）后 enc: 值
+ *  在本机必然 GCM 校验失败。消费方（registry 构建、websearch key 解析）据此
+ *  跳过该 provider/视为无 key 并提示重设，而不是让解密异常击穿启动/请求路径。 */
+export declare function decryptSecretSafe(stored: string): string | undefined;

package/dist/core/secret.js

@@ -49,3 +49,17 @@ export function decryptSecret(stored) {
     decipher.setAuthTag(tag);
     return Buffer.concat([decipher.update(enc), decipher.final()]).toString('utf8');
 }
+/** 解密存储值；失败（机器绑定密钥换机/密文损坏）返回 undefined 而非上抛。
+ *  机器绑定意味着密文不可跨机器解密——跨机同步配置（dotfiles/git）后 enc: 值
+ *  在本机必然 GCM 校验失败。消费方（registry 构建、websearch key 解析）据此
+ *  跳过该 provider/视为无 key 并提示重设，而不是让解密异常击穿启动/请求路径。 */
+export function decryptSecretSafe(stored) {
+    if (!stored.startsWith(PREFIX))
+        return stored;
+    try {
+        return decryptSecret(stored);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/skills.d.ts

@@ -0,0 +1,2 @@
+/** 发现当前项目可见的技能名（项目级 + 全局级，去重）。 */
+export declare function discoverSkills(cwd: string): string[];

package/dist/core/skills.js

@@ -0,0 +1,61 @@
+// 技能发现（system-prompt-overhaul plan 遗留的 skills 段数据源 + 主设计 §25
+// 「技能发现」的最小落地）：扫描项目 `.c0de/skills/` 与全局 `<config>/skills/`
+// 下每个含 SKILL.md 的目录，取 frontmatter `name`（缺省用目录名）作为技能名，
+// 由宿主注入 LoopDeps.skills → PromptContext.skills → system prompt 的
+// ## Loaded Skills 段。进程生命周期内按 cwd 缓存（技能是 system prompt 材料，
+// 运行中热加载无意义）。
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveGlobalConfigDir } from './config.js';
+const SKILL_FILE = 'SKILL.md';
+/** 从 SKILL.md 的 YAML frontmatter 取 name；无 frontmatter/无 name 用目录名。 */
+function parseSkillName(md, fallback) {
+    const fm = /^---\s*\n([\s\S]*?)\n---/.exec(md);
+    if (fm) {
+        const name = /^name:\s*(.+)$/m.exec(fm[1] ?? '');
+        if (name?.[1])
+            return name[1].trim();
+    }
+    return fallback;
+}
+/** 扫描一个技能目录：`<dir>/<name>/SKILL.md`。单个条目读取失败跳过。 */
+function scanDir(dir) {
+    if (!existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        try {
+            const path = join(dir, entry);
+            if (!statSync(path).isDirectory())
+                continue;
+            const skillMd = join(path, SKILL_FILE);
+            if (!existsSync(skillMd))
+                continue;
+            out.push(parseSkillName(readFileSync(skillMd, 'utf8'), entry));
+        }
+        catch {
+            // 单个技能损坏不阻断其余
+        }
+    }
+    return out.sort();
+}
+const cache = new Map();
+/** 发现当前项目可见的技能名（项目级 + 全局级，去重）。 */
+export function discoverSkills(cwd) {
+    const cached = cache.get(cwd);
+    if (cached)
+        return cached;
+    const names = Array.from(new Set([
+        ...scanDir(join(cwd, '.c0de', 'skills')),
+        ...scanDir(join(resolveGlobalConfigDir(), 'skills')),
+    ]));
+    cache.set(cwd, names);
+    return names;
+}

package/dist/core/slash.js

@@ -1,5 +1,6 @@
 import { resolve } from 'node:path';
 import { createSession, getSession } from '../session/session.js';
+import { isUuid } from '../shared/utils/string.js';
 import { PROJECT_BOUND_TOOLS, resolveEnabledToolNames } from '../tools/index.js';
 import { createAgent } from './agent.js';
 import { BUILTIN_WORKFLOWS, createWorkflowRegistry, discoverWorkflows, executeWorkflow, reloadRegistry, saveWorkflow, workflowSessionTitle, } from './workflows/index.js';
@@ -17,6 +18,11 @@ function parseSlashInput(input) {
  *  防 Web 端误输/被注入 id 清空或分支其他项目的会话。CLI 无当前会话上下文
  *  （sessionId 缺省）时放行——终端单用户显式操作。 */
 async function assertSameProjectSession(db, currentId, targetId) {
+    // 会话 id 是 uuid 列：非 UUID 经 getSession 的参数化查询在 PG 侧抛 22P02，
+    // 错误文本（含 SQL 细节）被透出为斜杠命令的错误消息——格式非法与「不存在」
+    // 同属资源不存在，统一为面向用户/模型的干净提示。
+    if (!isUuid(targetId))
+        throw new Error(`目标会话不存在：${targetId}`);
     const target = await getSession(db, targetId);
     if (!target)
         throw new Error(`目标会话不存在：${targetId}`);
@@ -207,7 +213,7 @@ const forkCommand = {
         }
         const { forkSession } = await import('../session/branch.js');
         try {
-            const forked = await forkSession(ctx.deps.db, sessionId, messageIndex);
+            const forked = await forkSession(ctx.deps.db, sessionId, messageIndex, ctx.deps.hookRunner);
             return { _tag: 'success', message: `已分支到新会话：${forked.id}` };
         }
         catch (error) {
@@ -258,25 +264,32 @@ const configCommand = {
                 message: 'security 是服务端全局参数，仅在全局作用域生效。请在全局配置（~/.c0de/config.json）中设置，或用 c0de config set --global 写入。',
             };
         }
-        const scopes = loadConfigScopes(ctx.cwd);
-        const value = coerce(parts.slice(1).join(' '));
-        const next = applyScopedPatch(scopes.project ?? {}, setPathPatch(key, value));
-        await saveConfigScoped('project', ctx.cwd, next);
-        // P1：/config 写入项目作用域是用户显式操作——已信任项目刷新风险指纹，
-        // 防「信任 → 改设置 → 再信任」自锁复检（与 /workflow create 同口径）。
         try {
-            const { getByDirectory, trustProject } = await import('../project/index.js');
-            const p = await getByDirectory(ctx.deps.db, ctx.cwd);
-            if (p?.trustedAt != null)
-                await trustProject(ctx.deps.db, p.id);
+            const scopes = loadConfigScopes(ctx.cwd);
+            const value = coerce(parts.slice(1).join(' '));
+            const next = applyScopedPatch(scopes.project ?? {}, setPathPatch(key, value));
+            await saveConfigScoped('project', ctx.cwd, next);
+            // P1：/config 写入项目作用域是用户显式操作——已信任项目刷新风险指纹，
+            // 防「信任 → 改设置 → 再信任」自锁复检（与 /workflow create 同口径）。
+            try {
+                const { getByDirectory, trustProject } = await import('../project/index.js');
+                const p = await getByDirectory(ctx.deps.db, ctx.cwd);
+                if (p?.trustedAt != null)
+                    await trustProject(ctx.deps.db, p.id);
+            }
+            catch {
+                // 指纹刷新失败不阻塞配置写入结果（最坏回到 fail-closed 复检路径）
+            }
+            return {
+                _tag: 'success',
+                message: `${value === null ? '已取消设置' : '已设置'} ${key} (scope: project)`,
+            };
         }
-        catch {
-            // 指纹刷新失败不阻塞配置写入结果（最坏回到 fail-closed 复检路径）
+        catch (error) {
+            // 非有限数值（1e999 → Infinity）等写入面校验失败：作为命令错误反馈给
+            // 模型/用户，而非击穿 SSE 流显示「连接中断」。
+            return { _tag: 'error', message: error instanceof Error ? error.message : String(error) };
         }
-        return {
-            _tag: 'success',
-            message: `${value === null ? '已取消设置' : '已设置'} ${key} (scope: project)`,
-        };
     },
 };
 const workflowCommand = {
@@ -487,7 +500,7 @@ const workflowCommand = {
                 plugins: ctx.config.plugins.enabled,
                 agentName: 'default',
             };
-            const session = await createSession(ctx.deps.db, workflowSessionTitle(name), workflowProjectId, 'workflow', undefined, undefined, ctx.cwd);
+            const session = await createSession(ctx.deps.db, workflowSessionTitle(name), workflowProjectId, 'workflow', undefined, undefined, ctx.cwd, undefined, ctx.deps.hookRunner);
             const parent = await createAgent(session, agentConfig, ctx.deps);
             return executeWorkflow({
                 registry,

package/dist/core/title.js

@@ -1,6 +1,7 @@
 import { chat as defaultChat } from '../llm/provider.js';
 import { buildFallbackChain } from '../llm/routing.js';
 import { updateSessionTitle } from '../session/session.js';
+import { headChars } from '../shared/utils/string.js';
 /** 会话默认占位标题；仍是该值时才有资格自动生成。 */
 const DEFAULT_SESSION_TITLE = 'New Session';
 /** 标题最长字符数，超出截断并加省略号。 */
@@ -72,7 +73,8 @@ function cleanTitle(raw) {
         .map((l) => l.trim())
         .find((l) => l.length > 0) ?? '';
     if (firstLine.length > TITLE_MAX_LENGTH) {
-        return `${firstLine.slice(0, TITLE_MAX_LENGTH - 3)}...`;
+        // headChars 内收切点，避免截断点落在代理对中间产出孤立码元
+        return `${headChars(firstLine, TITLE_MAX_LENGTH - 3)}...`;
     }
     return firstLine;
 }
@@ -130,7 +132,7 @@ async function fallbackTitleFromMessage(db, sessionId, firstMessage) {
     if (!firstLine)
         return;
     const title = firstLine.length > TITLE_MAX_LENGTH
-        ? `${firstLine.slice(0, TITLE_MAX_LENGTH - 3)}...`
+        ? `${headChars(firstLine, TITLE_MAX_LENGTH - 3)}...`
         : firstLine;
     await updateSessionTitle(db, sessionId, title).catch(() => { });
 }

package/dist/core/todo-tags.d.ts

@@ -31,10 +31,11 @@ type ApplyTodoTagsResult = {
     errors: string[];
     hasView: boolean;
 };
-/** Parse all todo tags from text, preserving document order. */
+/** Parse all todo tags from text, preserving document order.
+ *  Prose 感知：先剥离围栏代码块与行内代码——助手解释标签语法时的
+ *  ```/`` 示例不得触发真实状态变更（幽灵 done/start）。与 workflowz
+ *  关键词检测共用 markdown.ts 的剥离。 */
 export declare function parseTodoTags(text: string): ParsedTodoTag[];
-/** Resolve a seq string ("1-2" or "1") to a phase and/or task.
- *  Returns undefined if out of bounds or unparseable. */
 export declare function resolveSeq(phases: TodoPhase[], seq: string | undefined): {
     phase: TodoPhase;
     task?: TodoItem;

package/dist/core/todo-tags.js

@@ -1,6 +1,7 @@
 // todo-tags: parse <todo:*> tags from assistant text and apply them to todo phases.
 // Acts as a format-conversion layer on top of todo.ts's applyParams state machine.
 // Tags are NOT stripped from the text — they remain visible to the user.
+import { stripMarkdownCode } from '../shared/utils/markdown-code.js';
 import { applyParams, clonePhases, } from '../tools/builtin/todo.js';
 // =============================================================================
 // Tag parser
@@ -33,10 +34,13 @@ function parseInitInner(inner) {
     }
     return phases;
 }
-/** Parse all todo tags from text, preserving document order. */
+/** Parse all todo tags from text, preserving document order.
+ *  Prose 感知：先剥离围栏代码块与行内代码——助手解释标签语法时的
+ *  ```/`` 示例不得触发真实状态变更（幽灵 done/start）。与 workflowz
+ *  关键词检测共用 markdown.ts 的剥离。 */
 export function parseTodoTags(text) {
     const tags = [];
-    for (const m of text.matchAll(TAG_RE)) {
+    for (const m of stripMarkdownCode(text).matchAll(TAG_RE)) {
         const op = m[1] ?? '';
         const attrs = m[2] ?? '';
         const inner = m[3];
@@ -49,7 +53,7 @@ export function parseTodoTags(text) {
                 break;
             case 'append': {
                 const phaseMatch = /phase="([^"]+)"/.exec(attrs);
-                const phaseSeq = phaseMatch ? Number.parseInt(phaseMatch[1] ?? '', 10) : Number.NaN;
+                const phaseSeq = phaseMatch ? parseSeqNumber(phaseMatch[1] ?? '') : Number.NaN;
                 tags.push({ op: 'append', phaseSeq, items: parseItems(inner ?? '') });
                 break;
             }
@@ -74,12 +78,22 @@ export function parseTodoTags(text) {
 // =============================================================================
 /** Resolve a seq string ("1-2" or "1") to a phase and/or task.
  *  Returns undefined if out of bounds or unparseable. */
+/**
+ * 严格解析 seq 段：仅接受十进制非负整数整体。
+ * parseInt 会静默接受尾随垃圾/小数前缀/十六进制（'1.5'→1、'1x'→1、'0x2'→16），
+ * 畸形 seq 静默命中真实任务/阶段——统一先全串校验再转数值。
+ */
+function parseSeqNumber(s) {
+    return /^\d+$/.test(s) ? Number(s) : Number.NaN;
+}
 export function resolveSeq(phases, seq) {
     if (!seq)
         return undefined;
-    const parts = seq.split('-').map((s) => Number.parseInt(s.trim(), 10));
+    const parts = seq.split('-').map(parseSeqNumber);
+    if (parts.some(Number.isNaN) || parts.length > 2)
+        return undefined;
     const phaseNum = parts[0];
-    if (phaseNum === undefined || Number.isNaN(phaseNum))
+    if (phaseNum === undefined)
         return undefined;
     const phaseIdx = phaseNum - 1;
     if (phaseIdx < 0 || phaseIdx >= phases.length)
@@ -90,7 +104,7 @@ export function resolveSeq(phases, seq) {
     if (parts.length === 1)
         return { phase };
     const taskNum = parts[1];
-    if (taskNum === undefined || Number.isNaN(taskNum))
+    if (taskNum === undefined)
         return undefined;
     const taskIdx = taskNum - 1;
     if (taskIdx < 0 || taskIdx >= phase.tasks.length)