c0de-agent 1.13.0 → 1.14.0

package/dist/shared/utils/markdown-code.js

@@ -0,0 +1,44 @@
+/**
+ * Markdown 代码剥离：围栏代码块与行内代码一律移除，供「只该命中人类文字」的
+ * prose 感知检测共用（workflowz 关键词、<todo:*> 标签、composer 的 @agent
+ * 提及提取等）。
+ *
+ * 此前各检测点自带 ad-hoc 剥离（```...``` 非贪婪配对 + `[^`]*` 单反引号）——
+ * 未闭合围栏、~~~ 围栏、长反引号围栏、多反引号行内代码全部漏网：代码内容上的
+ * 关键词/标签/提及被误触发（工作流通告注入 / todo 状态幽灵变更 / 误派发子 agent）。
+ *
+ * 语义（保守方向——宁可多剥，不可在代码上误判）：
+ * - 围栏开启 = 行首（≤3 空格缩进）+ ≥3 个同字符反引号/波浪线；
+ *   闭合 = 同字符、长度 ≥ 开启、行内仅剩空白；未闭合围栏吞掉余文。
+ * - 行内代码 = 等长反引号对（``x`` 内可含单反引号，CommonMark 口径）。
+ */
+export function stripMarkdownCode(text) {
+    const lines = text.split('\n');
+    const out = [];
+    let fence = null;
+    for (const raw of lines) {
+        // CRLF：行尾 \r 不参与围栏判定，也不进入输出
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        const m = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+        if (!fence) {
+            if (m?.[1]) {
+                const run = m[1];
+                fence = { char: run[0] ?? '`', len: run.length };
+            }
+            else {
+                out.push(line);
+            }
+            continue;
+        }
+        // 围栏内：仅「同字符、长度 ≥ 开启、行内无其他字符」的行闭合围栏
+        const run = m?.[1];
+        if (run &&
+            run[0] === fence.char &&
+            run.length >= fence.len &&
+            line.slice(m[0].length).trim() === '') {
+            fence = null;
+        }
+        // 围栏内其余行（含闭合行）一律不输出
+    }
+    return out.join('\n').replace(/(`+)([\s\S]*?)\1/g, '');
+}

package/dist/shared/utils/path.d.ts

@@ -3,8 +3,11 @@
  * （如 `../etc/passwd`、绝对路径 `/etc/passwd`）。
  *
  * - `resolve(root, requestPath)` 解析后，若结果不在 root 子树内则返回 null。
- * - 判定逻辑：`relative(root, resolved)` 以 `..` 开头即越界；
+ * - 判定逻辑：`relative(root, resolved)` 为 `..` 或以 `..` 开头的**路径段**即越界；
  *   再用 `resolve(root, rel) === resolved` 兜底，防止相对段恰好名为 root 的边角情况。
+ *   越界判定必须按组件边界比较（`..` 整段 / `..<sep>` 前缀）——按字符串前缀
+ *   `rel.startsWith('..')` 会把以 `..` 开头的**合法文件名**（..foo、...、..bar/x）
+ *   一并拒绝：工作区内的真实文件/目录对工具与 /api/files 全部 403。
  * - symlink 防逃逸（P2-5）：root 与目标（或其最近已存在祖先）经 realpath 解析后，
  *   目标必须仍落在 root 实路径内；否则返回 null。
  *

package/dist/shared/utils/path.js

@@ -5,8 +5,11 @@ import { dirname, relative, resolve, sep } from 'node:path';
  * （如 `../etc/passwd`、绝对路径 `/etc/passwd`）。
  *
  * - `resolve(root, requestPath)` 解析后，若结果不在 root 子树内则返回 null。
- * - 判定逻辑：`relative(root, resolved)` 以 `..` 开头即越界；
+ * - 判定逻辑：`relative(root, resolved)` 为 `..` 或以 `..` 开头的**路径段**即越界；
  *   再用 `resolve(root, rel) === resolved` 兜底，防止相对段恰好名为 root 的边角情况。
+ *   越界判定必须按组件边界比较（`..` 整段 / `..<sep>` 前缀）——按字符串前缀
+ *   `rel.startsWith('..')` 会把以 `..` 开头的**合法文件名**（..foo、...、..bar/x）
+ *   一并拒绝：工作区内的真实文件/目录对工具与 /api/files 全部 403。
  * - symlink 防逃逸（P2-5）：root 与目标（或其最近已存在祖先）经 realpath 解析后，
  *   目标必须仍落在 root 实路径内；否则返回 null。
  *
@@ -15,7 +18,7 @@ import { dirname, relative, resolve, sep } from 'node:path';
 function safeResolve(root, requestPath) {
     const resolved = resolve(root, requestPath);
     const rel = relative(root, resolved);
-    if (rel.startsWith('..') || resolve(root, rel) !== resolved) {
+    if (rel === '..' || rel.startsWith(`..${sep}`) || resolve(root, rel) !== resolved) {
         return null;
     }
     try {

package/dist/shared/utils/string.d.ts

@@ -0,0 +1,5 @@
+/** 取至多 n 字符的前缀；切点绝不在代理对中间。n ≥ 文本长度时原样返回。 */
+export declare function headChars(text: string, n: number): string;
+/** 取至多 n 字符的后缀；切点绝不在代理对中间。n ≥ 文本长度时原样返回。 */
+export declare function tailChars(text: string, n: number): string;
+export declare function isUuid(value: string): boolean;

package/dist/shared/utils/string.js

@@ -0,0 +1,52 @@
+// 代理对安全的字符截断工具。
+//
+// UTF-16 下 emoji 等 astral 字符占两个码元（高代理 + 低代理）。直接 slice 会把
+// 代理对切成两半，产出孤立代理码元——经 JSON 序列化/UTF-8 编码往返后损坏为
+// U+FFFD（输出内容被静默改写）。所有「按字符数截断」的调用点都应经本模块
+// 把切点内收到安全边界。
+const isHighSurrogate = (c) => c >= 0xd800 && c <= 0xdbff;
+const isLowSurrogate = (c) => c >= 0xdc00 && c <= 0xdfff;
+/** 切点把代理对拆开时向左内收（丢弃悬空高代理码元）。 */
+function safeHeadEnd(text, end) {
+    while (end > 0 &&
+        end < text.length &&
+        isHighSurrogate(text.charCodeAt(end - 1)) &&
+        isLowSurrogate(text.charCodeAt(end))) {
+        end--;
+    }
+    return end;
+}
+/** 切点把代理对拆开时向右内收（跳过悬空低代理码元）。 */
+function safeTailStart(text, start) {
+    while (start > 0 &&
+        start < text.length &&
+        isHighSurrogate(text.charCodeAt(start - 1)) &&
+        isLowSurrogate(text.charCodeAt(start))) {
+        start++;
+    }
+    return start;
+}
+/** 取至多 n 字符的前缀；切点绝不在代理对中间。n ≥ 文本长度时原样返回。 */
+export function headChars(text, n) {
+    if (n <= 0)
+        return '';
+    if (n >= text.length)
+        return text;
+    return text.slice(0, safeHeadEnd(text, n));
+}
+/** 取至多 n 字符的后缀；切点绝不在代理对中间。n ≥ 文本长度时原样返回。 */
+export function tailChars(text, n) {
+    if (n <= 0)
+        return '';
+    if (n >= text.length)
+        return text;
+    return text.slice(safeTailStart(text, text.length - n));
+}
+/** UUID（任意版本/大小写）格式判定。
+ *  用于「路径/参数里的 id 直接进 PG uuid 列」的入口预检：非 UUID 经 drizzle
+ *  参数化查询会在 PG 侧抛 22P02（invalid input syntax for type uuid），被 Hono
+ *  兜成 500 并把 SQL 错误细节回给客户端——入口显式判非法（404）即可避免。 */
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isUuid(value) {
+    return UUID_RE.test(value);
+}

package/dist/tools/builtin/bash.js

@@ -1,7 +1,14 @@
 import { spawn } from 'node:child_process';
-import { resolve } from 'node:path';
+import { MAX_TIMER_MS } from '../../shared/timer.js';
+import { safeResolve } from '../../shared/utils/path.js';
+import { headChars } from '../../shared/utils/string.js';
 /** Default timeout: 120 seconds. */
 const DEFAULT_TIMEOUT = 120_000;
+/** stdout/stderr 各自捕获上限（字符）：命令输出在此之上的部分被丢弃并计数。
+ *  截断发生在命令运行期而非 close 之后——executor 的 truncateOutput 只能在
+ *  close 后裁剪，救不了累积期内存膨胀（`yes`/`find /` 几秒即可输出数 GB）。
+ *  256KB 留足 executor 的 head+tail 截断预算（默认 maxChars 100k）。 */
+const MAX_OUTPUT_CHARS = 256 * 1024;
 /** Kill an entire process tree (the child and all its descendants). */
 function killProcessTree(child) {
     try {
@@ -33,7 +40,7 @@ export const bashTool = {
         properties: {
             command: { type: 'string', description: 'Shell command to execute.' },
             cwd: { type: 'string', description: 'Working directory (default: ctx.cwd).' },
-            timeout: { type: 'number', description: 'Timeout in milliseconds (default: 120000).' },
+            timeout: { type: 'integer', description: 'Timeout in milliseconds (default: 120000).' },
             env: {
                 type: 'object',
                 description: 'Additional environment variables.',
@@ -45,7 +52,28 @@ export const bashTool = {
     permission: 'ask',
     execute: async (input, ctx) => {
         const { command, cwd, timeout = DEFAULT_TIMEOUT, env } = input;
-        const workDir = cwd ? resolve(ctx.cwd, cwd) : ctx.cwd;
+        // setTimeout 把 0/负数/Infinity（1e999）/NaN 全部钳到 ~1ms——命令刚 spawn
+        // 即被杀，模型收到「timeout after Infinityms」这类误导性错误，无法区分
+        // 「自己传了非法值」与「命令真超时」。显式报错供自纠。
+        // 同理，>2^31-1 的超大值（如 2^31）会被引擎钳到 1ms（TimeoutOverflowWarning）
+        // 而非「超长等待」——同样显式拒绝，上限即 Node timer 的 32 位安全上限。
+        if (!Number.isInteger(timeout) || timeout < 1 || timeout > MAX_TIMER_MS) {
+            return {
+                _tag: 'error',
+                error: `bash: timeout must be a positive integer (milliseconds, max ${MAX_TIMER_MS}), got ${timeout}`,
+            };
+        }
+        // 与 read/write/edit/glob/grep 同口径：cwd 必须落在工作目录内。此前直接
+        // resolve(ctx.cwd, cwd) 放行绝对路径/../——bash 是任意命令执行面，越界即
+        // 在工作目录外执行（如读取 ~/.ssh），且用户偏好可将 bash 设为 auto。
+        let workDir = ctx.cwd;
+        if (cwd) {
+            const resolved = safeResolve(ctx.cwd, cwd);
+            if (resolved === null) {
+                return { _tag: 'error', error: `cwd "${cwd}" escapes the working directory` };
+            }
+            workDir = resolved;
+        }
         return new Promise((resolvePromise) => {
             const childEnv = { ...process.env, ...env };
             const child = spawn(command, {
@@ -57,12 +85,37 @@ export const bashTool = {
             });
             let stdout = '';
             let stderr = '';
+            let droppedChars = 0;
             let timedOut = false;
+            /** 追加捕获并执行字符上限：超限部分丢弃计数，绝不无界累积。
+             *  切点经 headChars 内收，不产出孤立代理码元。 */
+            const appendCapped = (target, s) => {
+                const current = target === 'stdout' ? stdout : stderr;
+                if (current.length >= MAX_OUTPUT_CHARS) {
+                    droppedChars += s.length;
+                    return;
+                }
+                const next = current + s;
+                if (next.length > MAX_OUTPUT_CHARS) {
+                    droppedChars += next.length - MAX_OUTPUT_CHARS;
+                }
+                if (target === 'stdout') {
+                    stdout = headChars(next, MAX_OUTPUT_CHARS);
+                }
+                else {
+                    stderr = headChars(next, MAX_OUTPUT_CHARS);
+                }
+            };
+            // setEncoding('utf8') 让流内 StringDecoder 缓冲跨 chunk 的多字节序列：
+            // 此前按 chunk 逐个 Buffer.toString() 解码，UTF-8 序列被拆成两片时产出
+            // U+FFFD（如中文/emoji 输出静默损坏）。与 MCP/DAP transport 同口径。
+            child.stdout?.setEncoding('utf8');
+            child.stderr?.setEncoding('utf8');
             child.stdout?.on('data', (data) => {
-                stdout += data.toString();
+                appendCapped('stdout', data);
             });
             child.stderr?.on('data', (data) => {
-                stderr += data.toString();
+                appendCapped('stderr', data);
             });
             // Timeout handler
             const timer = setTimeout(() => {
@@ -80,7 +133,7 @@ export const bashTool = {
                 return;
             }
             ctx.abort.addEventListener('abort', onAbort, { once: true });
-            child.on('close', (code) => {
+            child.on('close', (code, signal) => {
                 clearTimeout(timer);
                 ctx.abort.removeEventListener('abort', onAbort);
                 if (ctx.abort.aborted) {
@@ -90,22 +143,38 @@ export const bashTool = {
                 if (timedOut) {
                     resolvePromise({
                         _tag: 'error',
-                        error: `Command timeout after ${timeout}ms\nPartial output:\n${stdout}${stderr}`,
+                        error: `Command timeout after ${timeout}ms\nPartial output:\n${stdout}${stderr}${droppedChars > 0 ? `\n[... ${droppedChars} chars of output dropped ...]` : ''}`,
                     });
                     return;
                 }
                 const output = stdout + (stderr ? `\n${stderr}` : '');
+                // 信号终止（code=null + signal 携带真实信号）：OOM killer / cgroup 限额 /
+                // 外部 kill / 命令自杀都走这里。此前只看 code——null 落进成功分支，工具
+                // 回 success 且 metadata.exitCode = code ?? 0 = 0，模型据此以为命令已跑完
+                //（如构建被 SIGKILL 后继续用半成品产物）。
+                if (signal !== null) {
+                    resolvePromise({
+                        _tag: 'error',
+                        error: `Command killed by signal ${signal}\n${output}${droppedChars > 0 ? `\n[... ${droppedChars} chars of output dropped ...]` : ''}`,
+                    });
+                    return;
+                }
                 if (code !== null && code !== 0) {
                     resolvePromise({
                         _tag: 'error',
-                        error: `Command failed with exit code: ${code}\n${output}`,
+                        error: `Command failed with exit code: ${code}\n${output}${droppedChars > 0 ? `\n[... ${droppedChars} chars of output dropped ...]` : ''}`,
                     });
                     return;
                 }
                 resolvePromise({
                     _tag: 'success',
-                    output: output || '(no output)',
-                    metadata: { exitCode: code ?? 0 },
+                    output: output +
+                        (droppedChars > 0 ? `\n[... ${droppedChars} chars of output dropped ...]` : '') ||
+                        '(no output)',
+                    metadata: {
+                        exitCode: code ?? 0,
+                        ...(droppedChars > 0 ? { droppedOutputChars: droppedChars } : {}),
+                    },
                 });
             });
             child.on('error', (err) => {

package/dist/tools/builtin/edit.js

@@ -70,9 +70,17 @@ export const editTool = {
             const newText = raw.newText;
             const content = await readFile(fullPath, 'utf-8');
             // Fuzzy whitespace matching: normalize whitespace runs
-            const normalize = (s) => s.replace(/[ \t]+/g, ' ');
+            // CRLF 行尾一并折叠：\r 对模型不可见，模型生成的 oldText 恒用 \n——
+            // 不折叠则 \n 版 oldText 在 CRLF 文件上恒不匹配（「oldText not found」）。
+            // 折叠后的位置经 buildPositionMapping 映射回原文（\r 按「原文多余空白」跳过）。
+            const normalize = (s) => s.replace(/\r\n/g, '\n').replace(/[ \t]+/g, ' ');
             const normalizedContent = normalize(content);
             const normalizedOld = normalize(oldText);
+            // 空 oldText 会让 indexOf('') 恒命中同一位置、searchFrom 永不前进——
+            // matches 推到 2^32 溢出（RangeError）前烧数秒 CPU 且报错无法指导模型。
+            if (normalizedOld.length === 0) {
+                return { _tag: 'error', error: `edit: oldText must not be empty for "${path}"` };
+            }
             // Find all match positions
             const matches = [];
             let searchFrom = 0;
@@ -99,7 +107,30 @@ export const editTool = {
             const mapping = buildPositionMapping(content, normalizedContent);
             const origStart = mapping.get(charCount) ?? charCount;
             const origEnd = mapping.get(charCount + normalizedOld.length) ?? charCount + normalizedOld.length;
-            const newContent = content.slice(0, origStart) + newText + content.slice(origEnd);
+            const newContent = (() => {
+                // 映射起点可能落在 CRLF 对中间：区域以 \n 开头时（normalize 把 \r\n 折成
+                // \n，映射把原文的 \r 当作「多余空白」跳过），前一行的 \r 留在区域外，
+                // 而 replacement 自带 \r\n → 拼成「\r\r\n」（孤立回车 + 原行尾被吃）；
+                // replacement 不含换行时 \r 更会留在行中（"line1\rX"）。与末尾守卫对称：
+                // 起点落在 CRLF 对中间时把 \r 纳入区域。
+                let start = origStart;
+                if (start > 0 && content[start - 1] === '\r' && content[start] === '\n')
+                    start--;
+                // 映射终点可能落在 CRLF 中间（region 吞入 \r，行尾 \n 留在区域外）：
+                // 把 \r 让回外部行尾，否则单行替换会产出「替换文本\n」丢失 \r 的混合行尾。
+                let end = origEnd;
+                if (end < content.length && content[end - 1] === '\r' && content[end] === '\n')
+                    end--;
+                // 行尾口径按**文件主导行尾**判定（与 hashline 模式/grep/shake/workflows 同口径）。
+                // 只看被替换区域是否含 CRLF 会在「单行区域 + 多行 newText」漏判——区域本身
+                // 不含换行，newText 的 \n 原样写入 CRLF 文件，产出混合行尾（git diff 全行噪音）。
+                // LF 文件同理：newText 里的 \r\n（模型粘贴 Windows 文本）此前原样写入，
+                // 与其余行混成混合行尾——两个方向都要归一（与 hashline 的同型修复一致）。
+                const replacement = content.includes('\r\n')
+                    ? newText.replace(/\r\n/g, '\n').replace(/\n/g, '\r\n')
+                    : newText.replace(/\r\n/g, '\n');
+                return content.slice(0, start) + replacement + content.slice(end);
+            })();
             await writeFile(fullPath, newContent, 'utf-8');
             return {
                 _tag: 'success',
@@ -124,6 +155,17 @@ function formatHashlineError(path, result) {
 /**
  * Build a mapping from normalized string positions to original string positions.
  * Used to map fuzzy match results back to the original content.
+ *
+ * normalize 的两条折叠规则各自需要**专门**的推进分支（此前只有一个「原文是空白
+ * 就只推进原文指针」的分支，掩盖了两条规则的区别）：
+ *  - `\r\n` → `\n`：原文的 \r 不产出任何 normalized 字符，只推进原文指针；
+ *  - `[ \t]+` → `' '`：原文整个空白 run 只产出**一个**空格，必须连同 normalized
+ *    侧的那个空格一起消费。
+ * 缺第二个分支时，run 首字符是空格（与 normalized 的空格相等，走对齐分支）、
+ * 其余空格走「只推进原文」分支，恰好正确；而 run 首字符是 tab 时首个不对齐处
+ * 落进「理论不可达」的兜底分支（两侧同时推进），此后整串错位一格——匹配区终点
+ * 落到目标之后，替换连紧随的换行与下一行首字符一起吃掉（静默源码损坏，工具
+ * 仍报 success）。
  */
 function buildPositionMapping(original, normalized) {
     const map = new Map();
@@ -131,19 +173,36 @@ function buildPositionMapping(original, normalized) {
     let normIdx = 0;
     while (origIdx < original.length && normIdx < normalized.length) {
         map.set(normIdx, origIdx);
-        if (original[origIdx] === normalized[normIdx]) {
+        const origChar = original[origIdx];
+        const normChar = normalized[normIdx];
+        if (origChar === normChar) {
             origIdx++;
             normIdx++;
+            continue;
         }
-        else if (original[origIdx] === ' ' || original[origIdx] === '\t') {
-            // Original has whitespace that was collapsed
+        // \r：CRLF 行尾在 normalize 中被折叠为 \n——映射时原文的 \r 是
+        // 「原文多余的空白」，仅前进原文指针（normIdx 停住等 \n 对齐）。
+        if (origChar === '\r') {
             origIdx++;
+            continue;
         }
-        else {
-            // Shouldn't happen with proper normalization
-            origIdx++;
+        // 空白 run 折叠为单个空格：吃掉整个 run，同时消费 normalized 侧的那个空格。
+        if (normChar === ' ' && (origChar === ' ' || origChar === '\t')) {
+            while (origIdx < original.length &&
+                (original[origIdx] === ' ' || original[origIdx] === '\t')) {
+                origIdx++;
+            }
             normIdx++;
+            continue;
+        }
+        // run 的后续空白（normalized 侧无对应字符）：只推进原文指针。
+        if (origChar === ' ' || origChar === '\t') {
+            origIdx++;
+            continue;
         }
+        // 理论上不可达（normalize 后两侧应逐字符对齐）：保守同步推进，绝不抛错。
+        origIdx++;
+        normIdx++;
     }
     // Map the end position
     map.set(normIdx, origIdx);

package/dist/tools/builtin/glob.js

@@ -1,5 +1,6 @@
 import { readdir } from 'node:fs/promises';
-import { join, relative, resolve } from 'node:path';
+import { join, relative } from 'node:path';
+import { safeResolve } from '../../shared/utils/path.js';
 /** Directories always skipped during glob traversal. */
 const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', '.next', 'build', '.turbo']);
 /**
@@ -7,16 +8,101 @@ const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', '.next', 'build', '
  * Supports: * (single segment), ** (across segments), ? (single char), {a,b} (alternation), [abc] (char class).
  */
 export function globToRegex(pattern) {
+    return new RegExp(`^${globFragment(pattern)}$`);
+}
+/** 把字面量文本转义为正则原文（用于降级路径：非法字符类/含空分支的花括号）。 */
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** 找到与 pattern[start]（'{'）配对的 '}'，计嵌套深度；未配对返回 -1。
+ *  此前用 indexOf('}') 只取第一个——{a,{b,c}} 被截到内层的 }，内层分支降级为
+ *  字面量，b/c 静默零命中。 */
+function findBraceEnd(pattern, start) {
+    let depth = 0;
+    for (let i = start; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '{')
+            depth++;
+        else if (c === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** 按顶层逗号切分花括号内容：嵌套花括号与字符类内的逗号属于内层，不参与切分。
+ *  字符类按 []a] 口径跳过类首字面量 ]（与 globFragment 的类解析同源）。 */
+function splitBraceAlternatives(inner) {
+    const alts = [];
+    let depth = 0;
+    let inClass = false;
+    let current = '';
+    for (let i = 0; i < inner.length; i++) {
+        const c = inner[i] ?? '';
+        if (inClass) {
+            if (c === ']')
+                inClass = false;
+            current += c;
+            continue;
+        }
+        if (c === '[') {
+            inClass = true;
+            current += c;
+            if (inner[i + 1] === ']') {
+                current += ']';
+                i++;
+            }
+            continue;
+        }
+        if (c === '{')
+            depth++;
+        else if (c === '}')
+            depth--;
+        if (c === ',' && depth === 0) {
+            alts.push(current);
+            current = '';
+            continue;
+        }
+        current += c;
+    }
+    alts.push(current);
+    return alts;
+}
+/** Convert a glob fragment (may appear inside brace alternation) to regex source.
+ *  Recursive so wildcards inside {a,b} stay wildcards instead of being escaped
+ *  as literals（此前 {*.spec.ts,*.test.ts} 恒不匹配任何文件）。
+ *  segStartAt0：fragment 起始位置是否算「段起点」——顶层模式为真；花括号分支
+ *  按分支前一个字符是否为 / 传入（{/**,x} 中的 ** 才是完整段）。 */
+function globFragment(pattern, segStartAt0 = true) {
     let re = '';
     let i = 0;
     while (i < pattern.length) {
         const c = pattern[i] ?? '';
         if (c === '*') {
             if (pattern[i + 1] === '*') {
-                re += '.*';
-                i += 2;
-                if (pattern[i] === '/')
-                    i++; // skip separator after **
+                const prev = pattern[i - 1];
+                const next = pattern[i + 2];
+                // 双星只在「完整段」（前后均无普通字符）时才有跨目录语义（bash globstar）。
+                const segStart = i === 0 ? segStartAt0 : prev === '/';
+                const segEnd = next === undefined || next === '/';
+                if (segStart && segEnd) {
+                    if (next === '/') {
+                        // **/ 整体表达「零或多个段」：恒译 .* 会把 a/**/b 译成 a/.*b，
+                        // 命中 a/xb、**/b 命中 foob（段边界失守）。
+                        re += '(?:.*/)?';
+                        i += 3;
+                    }
+                    else {
+                        re += '.*';
+                        i += 2;
+                    }
+                }
+                else {
+                    // 非段对齐的双星（a**b、**.ts）塌缩为单星，不跨目录。
+                    re += '[^/]*';
+                    i += 2;
+                }
             }
             else {
                 re += '[^/]*';
@@ -28,25 +114,73 @@ export function globToRegex(pattern) {
             i++;
         }
         else if (c === '{') {
-            const end = pattern.indexOf('}', i);
+            const end = findBraceEnd(pattern, i);
             if (end === -1) {
                 re += '\\{';
                 i++;
             }
             else {
                 const inner = pattern.slice(i + 1, end);
-                re += `(?:${inner.split(',').map(escapeRegex).join('|')})`;
+                const alts = splitBraceAlternatives(inner);
+                // 空分支（{a,}）会生成空交替 (?:a|)——空串匹配一切，静默过匹配。
+                // 含空分支整体降级为字面量（宁可零命中，不可命中一切）。
+                if (alts.some((alt) => alt.length === 0)) {
+                    re += `\\{${escapeRegex(inner)}\\}`;
+                }
+                else {
+                    const fragStartSeg = i === 0 ? segStartAt0 : pattern[i - 1] === '/';
+                    re += `(?:${alts.map((alt) => globFragment(alt, fragStartSeg)).join('|')})`;
+                }
                 i = end + 1;
             }
         }
         else if (c === '[') {
-            const end = pattern.indexOf(']', i);
+            // 类首 ] 是字面量成员（bash 口径：[]a] 匹配 ] 或 a）——跳过后找真正的闭合。
+            let end = pattern.indexOf(']', i);
+            if (end === i + 1) {
+                const realEnd = pattern.indexOf(']', i + 2);
+                if (realEnd !== -1)
+                    end = realEnd;
+            }
             if (end === -1) {
                 re += '\\[';
                 i++;
             }
             else {
-                re += pattern.slice(i, end + 1);
+                const inner = pattern.slice(i + 1, end);
+                // [] 在 JS 是「空类恒不匹配」（合法但不产生任何命中）——语义为字面量。
+                if (inner === '') {
+                    re += '\\[\\]';
+                    i = end + 1;
+                    continue;
+                }
+                // glob 取反语义：类首 ! 转为正则 ^；类首 ^ 在 bash 口径是字面量，
+                // 必须转义，否则被 JS 解释为取反（[!0-9]/[^a] 均曾静默语义反转）。
+                let cls = inner;
+                if (cls.startsWith('!')) {
+                    // 单独 [!]：取反空类在正则中是 [^]（匹配一切）——保持普通单成员类。
+                    if (cls.length === 1) {
+                        cls = '!';
+                    }
+                    else {
+                        cls = `^${cls.slice(1)}`;
+                    }
+                }
+                else if (cls.startsWith('^')) {
+                    cls = `\\^${cls.slice(1)}`;
+                }
+                else if (cls.startsWith(']')) {
+                    cls = `\\]${cls.slice(1)}`;
+                }
+                // 退化类（反向区间 [z-a] 等）此前直接拼进 new RegExp 抛 SyntaxError
+                // 击穿工具调用——探测编译失败时按字面量降级，绝不抛出。
+                try {
+                    new RegExp(`^[${cls}]$`);
+                    re += `[${cls}]`;
+                }
+                catch {
+                    re += `\\[${escapeRegex(inner)}\\]`;
+                }
                 i = end + 1;
             }
         }
@@ -59,10 +193,7 @@ export function globToRegex(pattern) {
             i++;
         }
     }
-    return new RegExp(`^${re}$`);
-}
-function escapeRegex(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return re;
 }
 /** Recursively walk a directory, skipping IGNORE_DIRS. Returns relative file paths. */
 async function walkDir(dir, base) {
@@ -101,7 +232,12 @@ export const globTool = {
     permission: 'auto',
     execute: async (input, ctx) => {
         const { pattern, path } = input;
-        const basePath = path ? resolve(ctx.cwd, path) : ctx.cwd;
+        // 与 read/write/edit 同口径：path 必须落在 cwd 内——permission 是 auto，
+        // 若放行绝对路径/../，模型可在无确认下枚举工作目录外（如 ~/.ssh）。
+        const basePath = path ? safeResolve(ctx.cwd, path) : ctx.cwd;
+        if (basePath === null) {
+            return { _tag: 'error', error: `Path "${path}" escapes the working directory` };
+        }
         try {
             const regex = globToRegex(pattern);
             const files = await walkDir(basePath, basePath);