c0de-agent 1.13.1 → 1.14.0

package/dist/core/workflow.d.ts

@@ -1,15 +1,3 @@
-/**
- * "workflowz" keyword support — Dynamic Workflow（spec: dynamic-workflow-design）。
- *
- * 用户在消息中包含独立单词 `workflowz` 时：
- *  1. 后端检测到关键词（prose 感知，忽略代码块/路径/大小写变体）
- *  2. 向当轮注入一条隐藏 system 通知（steering），引导模型用 `task` 工具批量 fan-out
- *     做确定性的多子 agent 工作流分解
- *
- * 复刻自 oh-my-pi 的 modes/workflow.ts，适配 c0de-agent 的 task 工具 schema：
- *  - 批量模式：`{ subagent_type, context, tasks: [{ prompt, description? }] }`
- *  - 单任务模式：`{ subagent_type?, prompt, description? }`
- */
 /**
  * 判断 `text` 是否在 prose 中包含独立关键词 "workflowz"。
  *
@@ -17,7 +5,10 @@
  * （中文无词间空格）；但仍拒绝 workflowzed / reworkflowz / workflowz.test.ts
  * 等拉丁词续或路径内嵌形式。
  *
- * 简化版 prose 检测：移除 ``` 代码块和 `行内代码` 后再匹配。
+ * prose 检测：先剥离围栏代码块与行内代码再匹配（shared/utils/markdown-code.ts 的
+ * stripMarkdownCode）——未闭合围栏、~~~ 围栏、长反引号围栏、多反引号
+ * 行内代码都会漏过此前的手写剥离，代码内容上的字面量关键字误触发
+ * 工作流通告注入。
  */
 export declare function containsWorkflow(text: string): boolean;
 /**

package/dist/core/workflow.js

@@ -10,6 +10,7 @@
  *  - 批量模式：`{ subagent_type, context, tasks: [{ prompt, description? }] }`
  *  - 单任务模式：`{ subagent_type?, prompt, description? }`
  */
+import { stripMarkdownCode } from '../shared/utils/markdown-code.js';
 // 检测：小写关键词，两侧不得是 ASCII 词/路径字符（字母、数字、_、.、/、-）。
 // 用 [\w./-] 而非 \S 做边界，使 CJK 字符和中文标点也能当边界——
 // 中文无词间空格，用 \S 会拒绝「请workflowz」「workflowz。」等合法写法。
@@ -22,14 +23,13 @@ const WORKFLOW_WORD = /(?<![\w./-])workflowz(?![\w./-])/;
  * （中文无词间空格）；但仍拒绝 workflowzed / reworkflowz / workflowz.test.ts
  * 等拉丁词续或路径内嵌形式。
  *
- * 简化版 prose 检测：移除 ``` 代码块和 `行内代码` 后再匹配。
+ * prose 检测：先剥离围栏代码块与行内代码再匹配（shared/utils/markdown-code.ts 的
+ * stripMarkdownCode）——未闭合围栏、~~~ 围栏、长反引号围栏、多反引号
+ * 行内代码都会漏过此前的手写剥离，代码内容上的字面量关键字误触发
+ * 工作流通告注入。
  */
 export function containsWorkflow(text) {
-    // 移除 ``` ... ``` 代码块
-    const withoutBlocks = text.replace(/```[\s\S]*?```/g, '');
-    // 移除 `行内代码`
-    const withoutInline = withoutBlocks.replace(/`[^`]*`/g, '');
-    return WORKFLOW_WORD.test(withoutInline);
+    return WORKFLOW_WORD.test(stripMarkdownCode(text));
 }
 /**
  * 工作流通知：注入为 steering system 消息，引导模型用 task 工具做批量 fan-out。

package/dist/core/workflows/context.js

@@ -1,5 +1,6 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { join, relative, resolve } from 'node:path';
+import { globToRegex } from '../../tools/builtin/glob.js';
 /** SubAgentResult → WorkflowAgentResult 映射。 */
 function mapResult(result) {
     if (result._tag === 'success') {
@@ -36,29 +37,19 @@ function buildWorkflowContext(opts) {
             return mapResult(result);
         },
         runSubagents: async (type, tasks, context) => {
-            const { mapWithConcurrencyLimit } = await import('../agents/parallel.js');
-            const concurrency = 3;
-            const { results } = await mapWithConcurrencyLimit(tasks, concurrency, async (task) => {
-                try {
-                    const result = await doRunSubAgent({
-                        agentType: type,
-                        prompt: task.assignment,
-                        description: task.description,
-                        role: task.role,
-                        context,
-                    });
-                    return mapResult(result);
-                }
-                catch (e) {
-                    // 隔离单个任务的异常：不向上抛，避免 mapWithConcurrencyLimit 的
-                    // fail-fast 终止所有尚未启动的兄弟任务。按合约返回 per-task { ok: false }。
-                    return {
-                        ok: false,
-                        error: e instanceof Error ? e.message : String(e),
-                    };
-                }
-            });
-            return results.filter((r) => r !== undefined);
+            const { runSubAgents } = await import('../loop/subagent.js');
+            const requests = tasks.map((task) => ({
+                agentType: type,
+                prompt: task.assignment,
+                ...(task.description ? { description: task.description } : {}),
+                ...(task.role ? { role: task.role } : {}),
+                ...(context ? { context } : {}),
+            }));
+            // 与 task 工具批量模式共用同一派发实现：并发上限取
+            // config.agents.subagentConcurrency（此前本模块硬编码 3，配置项形同虚设），
+            // 逐任务错误隔离与「结果顺序一致、无空洞」的契约同源。
+            const results = await runSubAgents(deps, parent, requests, doRunSubAgent);
+            return results.map(mapResult);
         },
         progress: onProgress,
         utils: {
@@ -74,8 +65,17 @@ function buildWorkflowContext(opts) {
                 const content = await readFile(absPath, 'utf-8');
                 if (!range)
                     return content;
+                // 与内置 read 工具同口径：range 未经校验直接进 slice(start - 1, end) 时
+                // start=0 经 slice(-1, end) 静默返回文件最后一行（0 基/1 基错位的最坏
+                // 形态）、小数行号被 slice 静默截断错行、end < start 静默空串——非法
+                // range 显式抛错让工作流作者/模型自纠；end 超出行数收敛到末行（与
+                // slice 语义一致）。
+                const { start, end } = range;
+                if (!Number.isInteger(start) || start < 1 || !Number.isInteger(end) || end < start) {
+                    throw new Error(`utils.read: invalid range { start: ${start}, end: ${end} } — start/end 必须是整数，start >= 1 且 end >= start`);
+                }
                 const lines = content.split('\n');
-                return lines.slice(range.start - 1, range.end).join('\n');
+                return lines.slice(start - 1, end).join('\n');
             },
             splitByDirectory: async (dir, opts) => {
                 return splitByDir(resolve(rootDir, dir), opts?.depth ?? 1, opts?.ignore ?? []);
@@ -84,46 +84,15 @@ function buildWorkflowContext(opts) {
     };
 }
 // ── 工具函数 ──
-/** 把 glob 模式编译为正则：双星号跨目录，单星号与问号不跨路径分隔符，其余字符转义。 */
-function globToRegExp(pattern) {
-    let re = '';
-    for (let i = 0; i < pattern.length; i++) {
-        const ch = pattern[i] ?? '';
-        if (ch === '*') {
-            if (pattern[i + 1] === '*') {
-                // `**/` 须能匹配零层目录（globstar 语义：src/**/*.ts 命中 src/a.ts）
-                if (pattern[i + 2] === '/') {
-                    re += '(?:.*/)?';
-                    i += 2;
-                }
-                else {
-                    re += '.*';
-                    i++;
-                }
-            }
-            else {
-                re += '[^/]*';
-            }
-        }
-        else if (ch === '?') {
-            re += '[^/]';
-        }
-        else if (/[.+^${}()|[\]\\]/.test(ch)) {
-            re += `\\${ch}`;
-        }
-        else {
-            re += ch;
-        }
-    }
-    return new RegExp(`^${re}$`);
-}
 /**
  * 递归 glob。模式含路径分隔符时按相对路径匹配（双星号跨目录，如「src 下任意层级的 .ts」）；
  * 不含分隔符时按文件名匹配（与旧行为兼容：星号 .ts 命中任意层级）。
+ * 模式翻译统一走 glob 工具的 globToRegex——此前本模块自带的翻译器不支持
+ * 字符类/花括号（静默零命中），两处语义发散已收敛为单一实现。
  */
 async function globRecursive(rootDir, pattern) {
     const results = [];
-    const regex = globToRegExp(pattern);
+    const regex = globToRegex(pattern);
     const matchRel = pattern.includes('/');
     async function walk(dir) {
         let entries;
@@ -180,8 +149,11 @@ async function grepRecursive(baseDir, pattern, rootDir) {
                 try {
                     const content = await readFile(fullPath, 'utf-8');
                     const lines = content.split('\n');
+                    // CRLF 文件行尾 \r 使 ^...$ 锚定匹配恒失败（与内置 grep 工具同型）。
+                    const crlf = content.includes('\r\n');
                     for (let i = 0; i < lines.length; i++) {
-                        const line = lines[i];
+                        const raw = lines[i];
+                        const line = crlf && raw?.endsWith('\r') ? raw.slice(0, -1) : raw;
                         if (line && regex.test(line)) {
                             results.push({
                                 path: relative(rootDir, fullPath),

package/dist/core/workflows/runtime.js

@@ -1,3 +1,4 @@
+import { clampTimerDelay, MAX_TIMER_MS } from '../../shared/timer.js';
 import { buildWorkflowContext } from './context.js';
 /** 工作流超时错误（用于 Promise.race 中识别超时）。 */
 class WorkflowTimeoutError extends Error {
@@ -47,15 +48,16 @@ async function executeWorkflow(opts) {
         onProgress: onProgress ?? (() => { }),
     });
     const { timeout } = entry.meta;
-    const hasTimeout = typeof timeout === 'number' && timeout > 0;
-    const timeoutSeconds = hasTimeout ? timeout : undefined;
+    // 声明的秒数转毫秒后须经 32 位上限钳制：超限（如 2^31 秒）会被 Node 钳到
+    // 1ms——工作流刚启动就被「超时」中止，且错误信息谎报原始时长；parent 的
+    // abort 级联还会被连带触发（同型：ToolDef.timeout 的钳制口径）。
+    const timeoutSpec = typeof timeout === 'number' && timeout > 0
+        ? { seconds: timeout, ms: clampTimerDelay(timeout * 1000, MAX_TIMER_MS, 1) }
+        : null;
     try {
         const execPromise = entry.execute(ctx);
-        const result = timeoutSeconds !== undefined
-            ? await Promise.race([
-                execPromise,
-                createTimeoutPromise(timeoutSeconds * 1000, timeoutSeconds),
-            ])
+        const result = timeoutSpec
+            ? await Promise.race([execPromise, createTimeoutPromise(timeoutSpec.ms, timeoutSpec.seconds)])
             : await execPromise;
         return {
             _tag: 'text',
@@ -75,7 +77,7 @@ async function executeWorkflow(opts) {
             }
             return {
                 _tag: 'error',
-                message: `Workflow "${name}" timed out after ${timeoutSeconds}s（执行已中止）`,
+                message: `Workflow "${name}" timed out after ${timeoutSpec?.seconds}s（执行已中止）`,
             };
         }
         return {

package/dist/dap/index.d.ts

@@ -2,5 +2,6 @@ export type { DAPClient, DAPMessage, DAPTransport } from './protocol.js';
 export { createDAPClient, createFramer, encodeMessage, } from './protocol.js';
 export type { DebugSessionManager, DebugSpawn } from './session.js';
 export { createDebugSessionManager, dapVariables } from './session.js';
+export { ADAPTER_COMMANDS, createDebugSpawn, resolveAdapterCommand } from './spawn.js';
 export { createProcessTransport } from './transport.js';
 export type { Breakpoint, DAPConfig, DAPSession, DebugStartInput, StackFrame, Variable, } from './types.js';

package/dist/dap/index.js

@@ -1,4 +1,5 @@
 // DAP 包（spec §21）：DAP 客户端、会话管理、进程 transport。
 export { createDAPClient, createFramer, encodeMessage, } from './protocol.js';
 export { createDebugSessionManager, dapVariables } from './session.js';
+export { ADAPTER_COMMANDS, createDebugSpawn, resolveAdapterCommand } from './spawn.js';
 export { createProcessTransport } from './transport.js';

package/dist/dap/protocol.d.ts

@@ -18,14 +18,19 @@ type DAPMessage = {
 };
 /** DAP 客户端：发 request 等 response，收 event。 */
 type DAPClient = {
-    /** 发请求，等对应 seq 的 response；失败 response reject。 */
-    request: (command: string, args?: unknown) => Promise<unknown>;
+    /** 发请求，等对应 seq 的 response；失败 response reject。
+     *  timeoutMs ≤ 0 表示不限时；缺省取 DEFAULT_REQUEST_TIMEOUT_MS。 */
+    request: (command: string, args?: unknown, timeoutMs?: number) => Promise<unknown>;
     /** 发事件通知（不等响应）。 */
     notify: (command: string, args?: unknown) => void;
     /** 订阅 event，返回取消订阅函数。 */
     on: (event: string, handler: (body: unknown) => void) => () => void;
     dispose: () => void;
 };
+/** 单请求默认超时：适配器进程存活但不响应（自身挂起、不支持的命令被静默忽略）时
+ *  拒绝而非永久挂起——debug_* 工具（ToolDef 无 timeout）与 start() 的 launch 都会
+ *  无限等待，整个 agent run 只能靠用户手动中止。与 MCP 客户端的单请求超时同型。 */
+declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
 /** 把一条 JSON 消息编码为 DAP 分帧字节（`Content-Length: N\r\n\r\n{json}`）。 */
 declare function encodeMessage(json: string): string;
 /** 输入流分帧器：喂字节，吐完整 JSON 消息。处理跨 chunk / 粘包。 */
@@ -37,4 +42,4 @@ declare function createFramer(): Framer;
 /** 创建 DAP 客户端。transport 由调用方提供（真实为适配器进程 stdio）。 */
 declare function createDAPClient(transport: DAPTransport): DAPClient;
 export type { DAPClient, DAPMessage, DAPTransport };
-export { createDAPClient, createFramer, encodeMessage };
+export { createDAPClient, createFramer, DEFAULT_REQUEST_TIMEOUT_MS, encodeMessage };

package/dist/dap/protocol.js

@@ -1,14 +1,27 @@
 // DAP 协议层（spec §21）：JSON-RPC over Content-Length 分帧。
 // 零外部依赖；transport 抽象分离 IO，协议层（编码/分帧/seq 配对）纯逻辑可测。
+/** 单请求默认超时：适配器进程存活但不响应（自身挂起、不支持的命令被静默忽略）时
+ *  拒绝而非永久挂起——debug_* 工具（ToolDef 无 timeout）与 start() 的 launch 都会
+ *  无限等待，整个 agent run 只能靠用户手动中止。与 MCP 客户端的单请求超时同型。 */
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 /** 把一条 JSON 消息编码为 DAP 分帧字节（`Content-Length: N\r\n\r\n{json}`）。 */
 function encodeMessage(json) {
     const len = Buffer.byteLength(json, 'utf8');
     return `Content-Length: ${len}\r\n\r\n${json}`;
 }
+/** 单帧 body 上限（字节）：Content-Length 是未受信输入——恶意/损坏适配器
+ *  声明巨大 body 时 `buffer.length < bodyStart + len` 恒成立，缓冲无限增长
+ *  且吞掉后续所有合法帧。超限声明视为协议错误，丢弃头部重新同步。 */
+const MAX_FRAME_BYTES = 64 * 1024 * 1024;
 function createFramer() {
     let buffer = Buffer.alloc(0);
     const handlers = [];
     function tryParse() {
+        // 缓冲硬上限：流中长时间无有效分帧头（垃圾字节流）时防无界增长。
+        // 保留尾部 4KB 作为重新同步窗口，其余丢弃。
+        if (buffer.length > MAX_FRAME_BYTES) {
+            buffer = buffer.subarray(buffer.length - 4096);
+        }
         // 找 header 结束分隔符 \r\n\r\n
         const sep = buffer.indexOf('\r\n\r\n');
         if (sep === -1)
@@ -23,6 +36,13 @@ function createFramer() {
             return;
         }
         const len = Number(m[1]);
+        // 超限/异常声明：丢弃该头重试，绝不为未受信长度无界缓冲
+        if (!Number.isSafeInteger(len) || len < 0 || len > MAX_FRAME_BYTES) {
+            buffer = buffer.subarray(sep + 4);
+            if (buffer.length > 0)
+                tryParse();
+            return;
+        }
         const bodyStart = sep + 4;
         if (buffer.length < bodyStart + len)
             return; // body 未到齐
@@ -53,6 +73,16 @@ function createDAPClient(transport) {
     const eventHandlers = new Map();
     const framer = createFramer();
     let disposed = false;
+    /** 终结一个 pending：清定时器 → 出表 → settle（幂等：超时/响应/关闭谁先到谁生效）。 */
+    const settle = (id, fn) => {
+        const p = pending.get(id);
+        if (!p)
+            return;
+        if (p.timer)
+            clearTimeout(p.timer);
+        pending.delete(id);
+        fn(p);
+    };
     framer.onMessage((json) => {
         let msg;
         try {
@@ -62,16 +92,17 @@ function createDAPClient(transport) {
             return;
         }
         if (msg.type === 'response') {
-            const p = pending.get(msg.request_seq ?? -1);
-            if (!p)
+            const requestSeq = msg.request_seq ?? -1;
+            if (!pending.has(requestSeq))
                 return;
-            pending.delete(msg.request_seq ?? -1);
-            if (msg.success === false) {
-                p.reject(new Error(msg.message || `DAP request ${msg.request_seq} failed`));
-            }
-            else {
-                p.resolve(msg.body);
-            }
+            settle(requestSeq, (p) => {
+                if (msg.success === false) {
+                    p.reject(new Error(msg.message || `DAP request ${requestSeq} failed`));
+                }
+                else {
+                    p.resolve(msg.body);
+                }
+            });
         }
         else if (msg.type === 'event') {
             const handlers = eventHandlers.get(msg.event ?? '');
@@ -83,21 +114,26 @@ function createDAPClient(transport) {
     transport.onData((chunk) => framer.feed(chunk));
     transport.onClose(() => {
         disposed = true;
-        for (const p of pending.values())
-            p.reject(new Error('DAP transport closed'));
-        pending.clear();
+        for (const id of Array.from(pending.keys())) {
+            settle(id, (p) => p.reject(new Error('DAP transport closed')));
+        }
     });
     function send(msg) {
         transport.write(encodeMessage(JSON.stringify(msg)));
     }
     return {
-        request(command, args) {
+        request(command, args, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
             if (disposed)
                 return Promise.reject(new Error('DAP client disposed'));
             seq += 1;
             const cur = seq;
             return new Promise((resolve, reject) => {
-                pending.set(cur, { resolve, reject });
+                const timer = timeoutMs > 0
+                    ? setTimeout(() => {
+                        settle(cur, (p) => p.reject(new Error(`DAP request "${command}" timed out after ${timeoutMs}ms`)));
+                    }, timeoutMs)
+                    : undefined;
+                pending.set(cur, { resolve, reject, ...(timer ? { timer } : {}) });
                 send({ seq: cur, type: 'request', command, arguments: args });
             });
         },
@@ -123,10 +159,10 @@ function createDAPClient(transport) {
                 return;
             disposed = true;
             transport.close();
-            for (const p of pending.values())
-                p.reject(new Error('DAP client disposed'));
-            pending.clear();
+            for (const id of Array.from(pending.keys())) {
+                settle(id, (p) => p.reject(new Error('DAP client disposed')));
+            }
         },
     };
 }
-export { createDAPClient, createFramer, encodeMessage };
+export { createDAPClient, createFramer, DEFAULT_REQUEST_TIMEOUT_MS, encodeMessage };

package/dist/dap/session.js

@@ -1,24 +1,64 @@
 import { generateId } from '../shared/index.js';
 import { createDAPClient } from './protocol.js';
 // ── 基于已建立 client 的原子操作（薄封装，对齐 DAP command） ──
+/** initialize/launch 超时：适配器首启（如 npx 下载 js-debug）可慢，给足余量；
+ *  超时拒绝并关闭 transport，避免 debug_start 永久挂住 agent run。 */
+const DAP_INIT_TIMEOUT_MS = 120_000;
+/** disconnect 超时：调试器可能已卡死，停止调试不应让工具再等满默认超时。 */
+const DAP_DISCONNECT_TIMEOUT_MS = 10_000;
 async function dapInitialize(client, adapterID) {
-    return client.request('initialize', {
+    return (await client.request('initialize', {
         clientID: 'c0de-agent',
         adapterID,
         linesStartAt1: true,
         columnsStartAt1: true,
         pathFormat: 'path',
-    });
+    }, DAP_INIT_TIMEOUT_MS));
 }
-async function dapLaunch(client, config) {
-    const cmd = config.request === 'attach' ? 'attach' : 'launch';
-    await client.request(cmd, {
+/**
+ * launch/attach 的参数。
+ *
+ * `type` 是适配器（尤其 js-debug）选择调试目标类型的字段：缺失时 js-debug 不创建
+ * 目标，launch 请求永不返回响应——start() 会一直等到 initialize 超时才报错，错误
+ * 文本还不指向根因。用 adapter id 作默认值（node→node、python→python…），
+ * launchArgs 可覆盖。
+ */
+function dapLaunchArguments(config) {
+    return {
+        type: config.adapter,
         program: config.program,
         args: config.args,
         cwd: config.cwd,
         stopOnEntry: false,
         ...config.launchArgs,
-    });
+    };
+}
+/**
+ * 发送 launch/attach 请求并返回「响应 promise」（不 await）。
+ * 必须能分两步：支持 configurationDone 的适配器（js-debug）在收到
+ * configurationDone 之前不返回 launch 响应——先 await launch 再发
+ * configurationDone 会互锁到超时。超时与 initialize 同口径（120s）：目标启动慢
+ * 时不应永久挂住 start()。
+ */
+function dapLaunchRequest(client, config) {
+    const cmd = config.request === 'attach' ? 'attach' : 'launch';
+    return client.request(cmd, dapLaunchArguments(config), DAP_INIT_TIMEOUT_MS);
+}
+/**
+ * 声明 supportsConfigurationDoneRequest 的适配器在启动目标前等待
+ * configurationDone（DAP 规范：客户端完成「启动前配置」后发送）。本客户端没有
+ * 独立的配置阶段（断点是启动后经 debug_breakpoint 增量设置），故紧接 launch 发送：
+ * 不发送时 js-debug 永远不启动目标——程序不运行、断点不命中、launch 响应不返回。
+ * 失败不致命（部分适配器实现宽松或不需要），但记录以便排查。
+ */
+const DAP_CONFIGURATION_DONE_TIMEOUT_MS = 10_000;
+async function dapConfigurationDone(client) {
+    try {
+        await client.request('configurationDone', {}, DAP_CONFIGURATION_DONE_TIMEOUT_MS);
+    }
+    catch (e) {
+        console.warn('[dap] configurationDone failed:', e instanceof Error ? e.message : String(e));
+    }
 }
 async function dapSetBreakpoints(client, file, bps) {
     return client.request('setBreakpoints', {
@@ -84,13 +124,32 @@ function createDebugSessionManager() {
             client.on('terminated', () => {
                 session.state = 'stopped';
             });
-            await dapInitialize(client, config.adapter);
-            await dapLaunch(client, config);
-            sessions.set(session.id, { session, client, config });
+            try {
+                const initBody = await dapInitialize(client, config.adapter);
+                // launch 响应与 configurationDone 有先后依赖：支持 configurationDone 的
+                // 适配器要收到它才创建/启动目标并回响应。先发 launch，再补 configurationDone，
+                // 最后 await launch 响应（见 dapLaunchRequest / dapConfigurationDone 注释）。
+                const launchPromise = dapLaunchRequest(client, config);
+                if (initBody?.supportsConfigurationDoneRequest === true) {
+                    await dapConfigurationDone(client);
+                }
+                await launchPromise;
+            }
+            catch (e) {
+                // 握手/launch 失败：dispose 关闭 transport（杀适配器子进程），不留悬挂会话。
+                client.dispose();
+                throw e;
+            }
+            sessions.set(session.id, { session, client, config, breakpoints: new Map() });
             return { sessionId: session.id, threadId: lastThread };
         },
         setBreakpoint(sessionId, bp) {
-            return dapSetBreakpoints(require(sessionId).client, bp.file, [bp]);
+            const managed = require(sessionId);
+            const existing = managed.breakpoints.get(bp.file) ?? [];
+            // 同一行重复设置（典型是补/改条件）替换旧条目，其余保留——断点集内不产生重复。
+            const next = [...existing.filter((b) => b.line !== bp.line), bp];
+            managed.breakpoints.set(bp.file, next);
+            return dapSetBreakpoints(managed.client, bp.file, next);
         },
         continue(sessionId, threadId) {
             return dapContinue(require(sessionId).client, threadId);
@@ -112,9 +171,9 @@ function createDebugSessionManager() {
             if (!s)
                 return;
             s.session.state = 'stopped';
-            // disconnect 适配器可能已退出；吞错但记录，便于排查非正常退出。
+            // disconnect 适配器可能已退出/卡死；吞错但记录，便于排查非正常退出。
             try {
-                await s.client.request('disconnect', {});
+                await s.client.request('disconnect', {}, DAP_DISCONNECT_TIMEOUT_MS);
             }
             catch (e) {
                 console.warn('[dap] disconnect failed:', e instanceof Error ? e.message : String(e));

package/dist/dap/spawn.d.ts

@@ -0,0 +1,11 @@
+import type { DebugSpawn } from './session.js';
+/** 已知适配器 → [command, args]。 */
+declare const ADAPTER_COMMANDS: Record<string, [string, string[]]>;
+/** 解析适配器 id → spawn 命令（导出供测试）。 */
+declare function resolveAdapterCommand(adapter: string): [string, string[]];
+/**
+ * 创建生产 DebugSpawn：按适配器映射 spawn 调试器进程，返回其 stdio 包装的
+ * DAPTransport。`overrides` 允许测试/高级用户注入自定义映射。
+ */
+declare function createDebugSpawn(overrides?: Record<string, [string, string[]]>): DebugSpawn;
+export { ADAPTER_COMMANDS, createDebugSpawn, resolveAdapterCommand };

package/dist/dap/spawn.js

@@ -0,0 +1,48 @@
+// DAP 宿主接线（spec §21）：把调试适配器 id 映射为可 spawn 的命令，包装成
+// DebugSpawn（session.ts 的依赖反转注入点）。此前无任何宿主注入 debugSpawn，
+// debug_start 恒报「no debug adapter spawn is wired」——本模块就是缺的那块。
+//
+// 已知适配器映射（stdlib 命名的保守默认）：
+//   node    → npx @bloopai/js-debug-adapter-stdio --stdio（官方 js-debug 的
+//             stdio 包装器：安装时从 microsoft/vscode-js-debug releases 下载
+//             官方 DAP server，运行时把 stdio 桥到其 TCP 端口；js-debug 自己
+//             spawn node --inspect）
+//   python  → python3 -m debugpy.adapter（需 pip install debugpy）
+//   go      → dlv dap（默认 stdio 模式）
+//   lldb    → lldb-dap（LLDB DAP 前端）
+// 未知 adapter id → 直接把 id 当作可执行命令名（如 "gdb" 的 DAP 包装器名），
+// 允许用户通过自定义适配器命令扩展。
+//
+// node 为何不用「官方包名」：js-debug 只以 VS Code 扩展 / GitHub release 分发，
+// npm 上并不存在 @vscode/js-debug 之类的官方 DAP server 包（此前映射的
+// `npx -y -p @vscode/js-debug js-debug --stdio` 恒 404，node 调试从第一步就
+// 起不来且报错不指向根因）。上面这个包装器是 npm 上可用的 stdio DAP server。
+import { createProcessTransport } from './transport.js';
+/** 已知适配器 → [command, args]。 */
+const ADAPTER_COMMANDS = {
+    // 包名即 bin 名，npx 直接解析；--stdio 是包装器自身的 stdio 模式开关。
+    node: ['npx', ['-y', '@bloopai/js-debug-adapter-stdio', '--stdio']],
+    python: ['python3', ['-m', 'debugpy.adapter']],
+    go: ['dlv', ['dap']],
+    lldb: ['lldb-dap', []],
+};
+/** 解析适配器 id → spawn 命令（导出供测试）。 */
+function resolveAdapterCommand(adapter) {
+    const known = ADAPTER_COMMANDS[adapter];
+    if (known)
+        return known;
+    return [adapter, []];
+}
+/**
+ * 创建生产 DebugSpawn：按适配器映射 spawn 调试器进程，返回其 stdio 包装的
+ * DAPTransport。`overrides` 允许测试/高级用户注入自定义映射。
+ */
+function createDebugSpawn(overrides) {
+    return (config) => {
+        const map = overrides ?? ADAPTER_COMMANDS;
+        const [command, args] = map[config.adapter] ?? [config.adapter, []];
+        const { transport } = createProcessTransport(command, args);
+        return transport;
+    };
+}
+export { ADAPTER_COMMANDS, createDebugSpawn, resolveAdapterCommand };

package/dist/dap/transport.js

@@ -4,11 +4,29 @@ function createProcessTransport(command, args = []) {
     const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
     const dataHandlers = [];
     const closeHandlers = [];
+    // spawn 失败（ENOENT 等）：无监听器时 unhandled 'error' 会击穿父进程。
+    // 仅记录——随后的 'close' 事件走既有关闭路径 reject pending。
+    child.on('error', (err) => {
+        console.warn(`[dap] 调试适配器进程错误：${err.message}`);
+    });
+    // 调试器进程崩溃/提前 close(0) 时 stdin 管道写入会异步触发 EPIPE 'error'，
+    // 该事件发在 stdin socket 上而非 child 上——无监听器同样击穿宿主进程。
+    child.stdin.on('error', (err) => {
+        console.warn(`[dap] 调试适配器 stdin 写入失败（进程可能已退出）：${err.message}`);
+    });
     child.stdout.setEncoding('utf8');
     child.stdout.on('data', (chunk) => {
         for (const h of dataHandlers)
             h(chunk);
     });
+    // 不读取 stderr 会让管道写满卡死子进程：适配器（js-debug 等）向 stderr 输出
+    // 日志/崩溃栈，同步写满 64KB 管道缓冲后阻塞在 write(2) 上，stdout 的 DAP 帧
+    // 永远发不出来（握手/请求全部等不到响应）。消费并透传到宿主 stderr——与 MCP
+    // stdio 传输同口径，同时保住适配器的错误输出可供排查。
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+        process.stderr.write(`[dap] ${chunk}`);
+    });
     child.on('close', () => {
         for (const h of closeHandlers)
             h();

package/dist/kanban/index.d.ts

@@ -1,2 +1,2 @@
 export type { DeletedKanbanBoard, KanbanTrashPurgeResult, MergeKanbanBoardResult, RestoreKanbanBoardResult, } from './store.js';
-export { createKanbanStore, getDeletedKanbanBoard, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPriorityError, listDeletedKanbanBoards, mergeKanbanBoard, permanentlyDeleteKanbanBoard, purgeDeletedKanbanBoards, restoreKanbanBoard, softDeleteKanbanBoard, } from './store.js';
+export { createKanbanStore, getDeletedKanbanBoard, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPositionError, KanbanInvalidPriorityError, listDeletedKanbanBoards, mergeKanbanBoard, permanentlyDeleteKanbanBoard, purgeDeletedKanbanBoards, restoreKanbanBoard, softDeleteKanbanBoard, } from './store.js';

package/dist/kanban/index.js

@@ -1 +1 @@
-export { createKanbanStore, getDeletedKanbanBoard, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPriorityError, listDeletedKanbanBoards, mergeKanbanBoard, permanentlyDeleteKanbanBoard, purgeDeletedKanbanBoards, restoreKanbanBoard, softDeleteKanbanBoard, } from './store.js';
+export { createKanbanStore, getDeletedKanbanBoard, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPositionError, KanbanInvalidPriorityError, listDeletedKanbanBoards, mergeKanbanBoard, permanentlyDeleteKanbanBoard, purgeDeletedKanbanBoards, restoreKanbanBoard, softDeleteKanbanBoard, } from './store.js';

package/dist/kanban/store.d.ts

@@ -19,6 +19,13 @@ declare class KanbanInvalidPriorityError extends Error {
     readonly value: string;
     constructor(value: string);
 }
+/** 非有限 position（如 JSON 1e999 → Infinity）。
+ *  写入 position 列后 max(position) 恒 Infinity，后续追加卡片全部同值并列、
+ *  排序静默失效且无法自愈——入口显式拒绝。 */
+declare class KanbanInvalidPositionError extends Error {
+    readonly value: number;
+    constructor(value: number);
+}
 /** 卡片不存在（update/move 目标 id 无效）。 */
 declare class KanbanCardNotFoundError extends Error {
     readonly cardId: string;
@@ -29,7 +36,7 @@ declare class KanbanCardNotFoundError extends Error {
  * The board is created on first access (lazy) with the default 5 columns.
  */
 declare function createKanbanStore(handle: DB, projectId: string): KanbanStore;
-export { createKanbanStore, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPriorityError, };
+export { createKanbanStore, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPositionError, KanbanInvalidPriorityError, };
 /** 回收站条目信息（列表展示用）。 */
 export type DeletedKanbanBoard = {
     id: string;