dsh-better-debug 0.0.0-stage → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/index.js ADDED
@@ -0,0 +1,1031 @@
1
+ import { appendFile, mkdir, readFile } from 'node:fs/promises'
2
+ import { readFileSync } from 'node:fs'
3
+ import { randomUUID, createHash } from 'node:crypto'
4
+ import { dirname, join, resolve, sep } from 'node:path'
5
+ import { homedir } from 'node:os'
6
+ import { fileURLToPath } from 'node:url'
7
+ import { registerPanel } from './panel.js'
8
+ import { messageText, estimateTokens } from './text.js'
9
+
10
+ /**
11
+ * dsh-better-debug — 卡住闸门的代码版。
12
+ *
13
+ * 背景:方法论(Mnemon `d713a6e6`)与 `stuck-gate` 技能都是**自觉条款**——
14
+ * 模型得先想起来自己卡住了,条款才会生效。可「想不起来」正是卡住时的症状本身。
15
+ * 这个插件把其中**能被事件证明**的部分升级成代码闸门:不看模型说了什么,
16
+ * 只看它做了什么。
17
+ *
18
+ * 三个信号(用户 2026-11-06 定稿:只做 1+2+4,收尾清零归 dsh-turn-cleanup):
19
+ * A 同一文件重复盲改 —— `fs/write-intent` 按路径计数「自上次测量以来」,第 N 次(默认 3)
20
+ * B 同一错误 episode —— 工具 + 目标 + 归一化指纹三者相同,第 N 次(默认 2)
21
+ * C 改完不测量又动手 —— 过 N 步没测量只进入 armed,**下一次写入之后**才说
22
+ *
23
+ * v0.2 的四处语义修正(依据 2026-11-14 评审):
24
+ * 1. 「工具被调用」≠「测量完成」:`ops_bash` 先按命令/描述判是不是测量,
25
+ * 且只在**结果返回后**才清零盲改计数 —— `edit → ls → edit → edit` 不再被洗白。
26
+ * 2. 测量是**意图 + 结果**两段:`exitCode != 0` 的失败测试仍然是有效测量(它给了新事实)。
27
+ * 3. C 不再按步数闹钟打断阅读:arm 之后要等**真的又写了一次**才开口。
28
+ * 4. B 按 episode 计数(工具 + 目标 + 指纹),一次无关搜索不再永久关掉全部 B 提醒。
29
+ *
30
+ * 不做的事:
31
+ * - 不做「我猜是」措辞检测(插件看不见模型内心独白,留给 skill 自检)
32
+ * - 不做收尾探针清零(归 dsh-turn-cleanup)
33
+ * - 不用 `{kind:'reject'}`(那会把整个 turn 变成 no-op),只往 messages 尾部追加一条
34
+ * - 不对子会话生效(`origin === 'subagent'` 或 `delegationDepth > 0` 直接跳过)
35
+ * - 不做 no-op 写入判定:`fs/write-intent` 的 intent 只有 freshness token
36
+ * (`createIfAbsent` / `replaceIfVersion`),不带内容,拿不到 diff。
37
+ *
38
+ * D 段例外(AGENTS.md):读出本 turn 最后一条用户原话,命中「别搜/直接改/快速试/
39
+ * 不用搜」就整 turn 静音 —— 用户显式要求硬来的时候不做任何事。
40
+ *
41
+ * 幂等:同一局面不重复念;拿到有效测量后重新武装,再犯可以再说一次,
42
+ * 但每 turn 有总预算(默认 3 次)。
43
+ */
44
+
45
+ export const name = 'dsh-better-debug'
46
+ // 一个都不声明 —— 这是刻意的。
47
+ //
48
+ // cordis 的 `Fiber._refresh()` 只要 `inject` 里有一个服务拿不到,就把 epoch 置成
49
+ // INACTIVE 并**直接不执行 apply**:没有报错、没有日志、插件在面板里看起来"装上了",
50
+ // 实际一行代码都没跑。`skills` 由 `@deepseek-ai/dsh-skill` 提供,用户裁剪过的
51
+ // profile、别的发行版、或只是没启用那个包时,它就不在 —— 而闸门本身根本不需要它。
52
+ //
53
+ // 所以两个可选服务(skills / webServer)都改用 `ctx.inject([...], cb)` 动态订阅:
54
+ // 服务在就挂上,不在就只是少一个可选功能,闸门照常工作。
55
+ export const inject = []
56
+
57
+ /** 自带技能的名字。注入文本里写的就是它,改这里要同步改 assets 与 text.js。 */
58
+ const BUNDLED_SKILL_NAME = 'stuck-gate'
59
+ const BUNDLED_SKILL_RANK = 600 // = BUNDLED_SKILL_RANK,与 dsh-skill-office 一致
60
+ const ASSET_ROOT = fileURLToPath(new URL('../assets/', import.meta.url))
61
+
62
+ /**
63
+ * 默认日志文件名。**不能**用 `${name}.log`(那是 `dsh-better-debug.log`):
64
+ * 文档、面板、老用户手配的路径都写 `better-debug.log`,两处不一致时
65
+ * 用户按文档去翻目录会扑空,而且旧测试的 `endsWith('better-debug.log')`
66
+ * 对 `dsh-better-debug.log` 也成立 —— 断言绿着,文件却不在文档说的位置。
67
+ */
68
+ const DEFAULT_LOG_NAME = 'better-debug.log'
69
+
70
+ /** 全局调用一次就能拿到外部先验的那些工具。 */
71
+ export const SEARCH_TOOLS = new Set([
72
+ 'web_search',
73
+ 'research',
74
+ 'advanced_search',
75
+ 'multi_search',
76
+ 'platform_search',
77
+ 'domain_search',
78
+ 'cache_search',
79
+ 'video_search'
80
+ ])
81
+
82
+ /** 语义上「一定在测量」的工具,不需要再看参数。 */
83
+ export const HARD_MEASURE_TOOLS = new Set(['lsp_diagnostics', 'verify', 'run_tests', 'run_test'])
84
+
85
+ /** 要按参数再判一次的工具(`ops_bash` 既能跑测试也能 `ls`)。 */
86
+ export const SOFT_MEASURE_TOOLS = new Set(['ops_bash', 'bash', 'shell', 'pwsh'])
87
+
88
+ /** 会改动仓库那类工具。 */
89
+ export const EDIT_TOOLS = new Set(['edit', 'write', 'ops_write', 'str_replace', 'apply_patch', 'notebook_edit'])
90
+
91
+ /**
92
+ * 默认「这条命令算测量」的判据。
93
+ *
94
+ * 误判的两个方向都真实存在:把 `ls` 当验证会**漏报**盲改(v0.1.2 的问题);
95
+ * 把 `npm test` 当验证则可能**误报**「你在打通关」——所以判据要窄,
96
+ * 且宁可漏判(不说)也不要错判(乱说)。用户可用 `measureCommands` 覆盖。
97
+ */
98
+ const DEFAULT_MEASURE_COMMANDS = [
99
+ '(npm|pnpm|yarn|bun)\\s+(run\\s+)?(test|verify|check|lint|typecheck|build)',
100
+ 'node\\s+--test',
101
+ 'node\\s+test[/\\\\]',
102
+ 'pytest',
103
+ 'vitest',
104
+ 'jest',
105
+ 'mocha',
106
+ 'go\\s+(test|vet|build)',
107
+ 'cargo\\s+(test|check|clippy|build)',
108
+ 'dotnet\\s+(test|build)',
109
+ 'tsc(\\s|$)',
110
+ 'eslint',
111
+ 'ruff\\s+check',
112
+ 'mypy',
113
+ 'python\\s+-m\\s+(pytest|unittest)',
114
+ 'git\\s+diff\\s+--stat'
115
+ ].join('|')
116
+
117
+ /**
118
+ * 命令本身看不出来时,退一步看模型的 `description`(ops_bash 必填)。
119
+ * 这是「自称在测量」,弱于命令,但比把 `ls` 当验证强。
120
+ */
121
+ const DEFAULT_MEASURE_INTENT = '验证|测试|复现|统计|测量|诊断|跑一遍|看看结果|verify|test|repro|measure|diagnos'
122
+
123
+ /** 不该计入「盲改」的路径:生成物、锁文件、日志、构建产物。 */
124
+ const DEFAULT_EXCLUDE_PATHS = [
125
+ '(^|[/\\\\])(node_modules|dist|build|out|coverage|\\.git|\\.next|\\.cache)[/\\\\]',
126
+ '(^|[/\\\\])(package-lock\\.json|pnpm-lock\\.yaml|yarn\\.lock|bun\\.lockb)$',
127
+ '\\.(log|lock|map|min\\.js)$'
128
+ ].join('|')
129
+
130
+ /** D 段例外:用户显式要求别折腾。 */
131
+ const QUIET_PATTERN = /别搜|不要搜|不用搜|先别搜|直接改|快速试|别折腾|先试试/
132
+
133
+ function toRegExp(source, fallback) {
134
+ if (typeof source !== 'string' || source.trim().length === 0) return fallback
135
+ try {
136
+ return new RegExp(source, 'i')
137
+ } catch {
138
+ return fallback
139
+ }
140
+ }
141
+
142
+ /** `~` / `~/x` → 家目录。用户手写配置时最爱用的写法,Windows 上也认。 */
143
+ function expandHome(path) {
144
+ if (path === '~') return homedir()
145
+ if (path.startsWith('~/') || path.startsWith('~\\')) return join(homedir(), path.slice(2))
146
+ return path
147
+ }
148
+
149
+ /**
150
+ * 日志落到哪个文件。
151
+ *
152
+ * v0.2.0 之前默认是空字符串 = 完全不落盘。后果对新用户很致命:
153
+ * 装完、重启、打开面板,**四张卡全是 0**,看起来像「插件根本没工作」——
154
+ * 而想看到数据必须自己配一个绝对路径,绝大多数人不会配。
155
+ * 默认必须开箱就有数据。
156
+ *
157
+ * undefined / 没写 → $DSH_HOME/logs/better-debug.log(与 dsh-turn-cleanup 一致)
158
+ * "" 或 false(显式) → 不落盘,留一个干净的退出闸(测试也用它)
159
+ * "~/x.log" → 展开家目录
160
+ * "C:/x.log" → 原样
161
+ */
162
+ export function resolveLogFile(raw) {
163
+ if (raw.logFile === false) return ''
164
+ if (typeof raw.logFile === 'string') {
165
+ const trimmed = raw.logFile.trim()
166
+ if (trimmed.length === 0) return ''
167
+ return expandHome(trimmed)
168
+ }
169
+ // 目录要绝对:DSH_HOME 允许被写成相对路径(用户手写配置时很常见),
170
+ // 而日志路径若跟着相对,就会解析到**进程当下的 cwd**——插件跑在 DSH 主机进程里,
171
+ // 那个 cwd 由用户从哪儿启动决定,事后没人猜得到日志写去了哪。
172
+ const home = resolve(process.env.DSH_HOME || join(homedir(), '.dsh'))
173
+ return join(home, 'logs', DEFAULT_LOG_NAME)
174
+ }
175
+
176
+ function normalizeConfig(config) {
177
+ const raw = config !== null && typeof config === 'object' ? config : {}
178
+ const num = (value, fallback, min, max) =>
179
+ Number.isFinite(value) ? Math.max(min, Math.min(max, value)) : fallback
180
+ return {
181
+ enabled: raw.enabled !== false,
182
+ repeatEditThreshold: num(raw.repeatEditThreshold, 3, 2, 20),
183
+ repeatErrorThreshold: num(raw.repeatErrorThreshold, 2, 2, 20),
184
+ noVerifySteps: num(raw.noVerifySteps, 2, 1, 20),
185
+ // 一次测量(结果返回)就清零连续盲改计数:有测量回路的收敛不算卡住。
186
+ decayEditsOnVerify: raw.decayEditsOnVerify !== false,
187
+ // present 成功之后休眠闸门,下一次写入重新唤醒:修掉交付后误触发。
188
+ doneOnPresent: raw.doneOnPresent !== false,
189
+ // 每 turn 最多说几次:拿到测量后允许重新武装,但不能变成连击。
190
+ maxInjectsPerTurn: num(raw.maxInjectsPerTurn, 3, 1, 10),
191
+ // 注入后盯多少步,看模型有没有真的转去验证/搜索(面板的 steps 就靠它)。
192
+ changedWindow: num(raw.changedWindow, 6, 1, 30),
193
+ // 判「这条命令是不是测量」。给字符串覆盖,给了坏正则就回退默认。
194
+ measureCommands: toRegExp(raw.measureCommands, new RegExp(DEFAULT_MEASURE_COMMANDS, 'i')),
195
+ measureIntent: toRegExp(raw.measureIntent, new RegExp(DEFAULT_MEASURE_INTENT, 'i')),
196
+ // 不计入盲改的路径(生成物 / 锁文件 / 日志)。
197
+ excludePaths: toRegExp(raw.excludePaths, new RegExp(DEFAULT_EXCLUDE_PATHS, 'i')),
198
+ logFile: resolveLogFile(raw),
199
+ // 面板是纯只读视图;关掉它不影响闸门。
200
+ panel: raw.panel !== false
201
+ }
202
+ }
203
+
204
+ /** 与 dsh-workspace-changes / dsh-turn-cleanup 同一套判定:子会话不管。 */
205
+ function eligible(session) {
206
+ const header = session === null || session === void 0 ? void 0 : session.header
207
+ if (header === null || header === void 0) return false
208
+ const { origin, delegationDepth } = header
209
+ if (origin === 'subagent' || (delegationDepth ?? 0) > 0) return false
210
+ return true
211
+ }
212
+
213
+ /** target 对象 → 绝对路径(不依赖 fs 服务,避免额外 inject)。 */
214
+ function targetPath(target) {
215
+ if (typeof target === 'string') return target
216
+ if (target === null || target === void 0) return void 0
217
+ const key = target.targetKey
218
+ return typeof key === 'string' && key.length > 0 ? key : void 0
219
+ }
220
+
221
+ /**
222
+ * 是否是绝对路径 —— **两种方言都认**。
223
+ *
224
+ * `node:path` 的 `isAbsolute` 是平台相关的:在 Linux/macOS 上
225
+ * `isAbsolute('C:/work/a.js')` 是 **false**,在 Windows 上
226
+ * `isAbsolute('/home/u/a.js')` 是 true。这个插件后面所有的判据
227
+ * (`errorFingerprint` / `errorTargetOf` / `measureDirs`)都同时认 `C:/` 与 `/`
228
+ * 两种写法,唯独入口这道闸用平台函数,就会出现「判据说它见过这个路径、
229
+ * 但计数从来没加上」的自相矛盾。
230
+ *
231
+ * 真实会踩到的三种情况:远程/SSH 会话把 Windows 路径带进 POSIX 宿主、
232
+ * 配置里写死了另一种方言、以及 CI 在三个 OS 上跑同一套用例。
233
+ * 所以这里只问「它是不是从根开始的」,不问「根长得像不像本机的」。
234
+ */
235
+ export function isAbsPath(path) {
236
+ if (typeof path !== 'string' || path.length === 0) return false
237
+ // `/x`、`\\server\share`、`C:/x`、`C:\x`、`//server/share`
238
+ return /^(?:[A-Za-z]:[\\/]|[\\/])/.test(path)
239
+ }
240
+
241
+ /**
242
+ * 比较路径前要不要折叠大小写。
243
+ *
244
+ * Windows 与 macOS 的默认文件系统不区分大小写,`C:/Work/a.js` 与 `c:/work/a.js`
245
+ * 是同一个文件;Linux 区分,它们是两个不同文件。折叠错了的后果**不对称**:
246
+ * · 在不区分的系统上不折叠 → 同一个文件被当成两个,A 少报一次(漏);
247
+ * · 在区分的系统上折叠 → 两个不同文件被当成一个,B 误报(狼来了)。
248
+ * 后者正是这道闸门最不能犯的错,所以按平台判,而不是无条件 `toLowerCase()`。
249
+ * macOS 有人会装区分大小写的 APFS,那种机器上这里会少报 —— 仍然是安全方向。
250
+ */
251
+ export const CASE_INSENSITIVE = process.platform === 'win32' || process.platform === 'darwin'
252
+
253
+ /** 需要拿路径做相等/前缀比较时统一走这里,别直接 `toLowerCase()`。 */
254
+ function foldCase(text) {
255
+ return CASE_INSENSITIVE ? text.toLowerCase() : text
256
+ }
257
+
258
+ /** 规整成一个可比对的目录:posix 分隔符、去尾斜杠、按平台折叠大小写。 */
259
+ function normDir(path) {
260
+ const normalized = String(path ?? '').replace(/\\/g, '/').replace(/\/+$/, '')
261
+ return foldCase(normalized)
262
+ }
263
+
264
+ /**
265
+ * 文件路径 → 它所在的目录。
266
+ *
267
+ * 注意别把**目录**喂进来:`dirOf('C:/other')` 会返回 `'c:'`(把 other 当成文件名取了父目录),
268
+ * 而 `'c:'` 作为前缀能匹配整个 C 盘 —— 一次无关目录的测试就会把所有文件的盲改计数洗白。
269
+ * 目录一律走 `normDir`,只有编辑/写入的**文件路径**才走这里。
270
+ */
271
+ function dirOf(path) {
272
+ const normalized = String(path ?? '').replace(/\\/g, '/')
273
+ const cut = normalized.lastIndexOf('/')
274
+ return normDir(cut > 0 ? normalized.slice(0, cut) : normalized)
275
+ }
276
+
277
+ /**
278
+ * 一次工具调用归成某一类,面板据此算「注入后模型换动作了吗」。
279
+ * `measure` 由调用方算好传进来:`ops_bash` 的归类取决于参数,不看参数归不了类。
280
+ */
281
+ export function classifyTool(name, measure) {
282
+ if (typeof name !== 'string') return 'other'
283
+ if (SEARCH_TOOLS.has(name)) return 'search'
284
+ if (HARD_MEASURE_TOOLS.has(name)) return 'verify'
285
+ if (SOFT_MEASURE_TOOLS.has(name)) return measure === true ? 'verify' : 'shell'
286
+ if (EDIT_TOOLS.has(name)) return 'edit'
287
+ if (name === 'skill') return 'method'
288
+ return 'other'
289
+ }
290
+
291
+ /** 这条 `ops_bash` 调用算不算一次测量(意图层,结果层还要看 exitCode)。 */
292
+ export function isMeasurement(name, args, cfg) {
293
+ if (HARD_MEASURE_TOOLS.has(name)) return true
294
+ if (!SOFT_MEASURE_TOOLS.has(name)) return false
295
+ const command = typeof args?.command === 'string' ? args.command : ''
296
+ const script = typeof args?.script_path === 'string' ? args.script_path : ''
297
+ const description = typeof args?.description === 'string' ? args.description : ''
298
+ if (command.length > 0 && cfg.measureCommands.test(command)) return true
299
+ if (script.length > 0 && cfg.measureCommands.test(script)) return true
300
+ // 只剩「自称在测量」这一条弱证据时,要求它同时不像读文件/列目录。
301
+ if (description.length > 0 && cfg.measureIntent.test(description)) {
302
+ return !/^\s*(ls|dir|cat|type|head|tail)\b/i.test(command)
303
+ }
304
+ return false
305
+ }
306
+
307
+ /**
308
+ * 这次测量「管得到」哪些目录。
309
+ *
310
+ * `workdir` 本身是目录(直接规整);命令里出现的路径可能是文件也可能是目录,
311
+ * 一律按目录处理(`npm test -- src/a.test.js` 的父目录同样是它的管辖范围)。
312
+ */
313
+ export function measureDirs(args) {
314
+ const dirs = new Set()
315
+ const workspace = normDir(args?.workdir)
316
+ if (workspace.length > 0) dirs.add(workspace)
317
+ const collect = (text) => {
318
+ if (typeof text !== 'string' || text.length === 0) return
319
+ for (const match of text.matchAll(/[A-Za-z]:[\\/][^\s"'`;,)]+|\/(?:[\w.-]+\/)+[\w.-]*/g)) {
320
+ dirs.add(dirOf(match[0]))
321
+ }
322
+ }
323
+ collect(args?.command)
324
+ collect(args?.script_path)
325
+ return dirs
326
+ }
327
+
328
+ /**
329
+ * 错误文本 → 稳定指纹。目标不是「相等」而是「同一类」:
330
+ * 报错变的是行号、时间戳、临时路径、内存地址,不变的是异常类和消息骨架。
331
+ */
332
+ export function errorFingerprint(text) {
333
+ const head = String(text ?? '')
334
+ .split('\n')
335
+ .slice(0, 6)
336
+ .join('\n')
337
+ const normalized = head
338
+ .replace(/\b[0-9a-f]{8,}\b/gi, '<hex>')
339
+ .replace(/[A-Za-z]:\\[^\s"']+/g, '<path>')
340
+ .replace(/(?<![\w.])\.{0,2}\/[^\s"']{6,}/g, '<path>')
341
+ .replace(/\d+(?:\.\d+)?/g, '<n>')
342
+ .replace(/\s+/g, ' ')
343
+ .trim()
344
+ .slice(0, 300)
345
+ return createHash('sha256').update(normalized, 'utf8').digest('hex').slice(0, 16)
346
+ }
347
+
348
+ /**
349
+ * 报错文本里的「目标」——第一个像路径的东西,数字归一化后保留。
350
+ *
351
+ * B 的 episode key 需要它:`open 'C:/work/a.js'` 与 `open 'C:/work/b.js'`
352
+ * 是同一类 ENOENT,但不是同一个 episode,不能合并计数(否则两个文件各错一次
353
+ * 就被当成「同一个报错吃了两次」)。
354
+ */
355
+ export function errorTargetOf(text) {
356
+ const match = /(?:[A-Za-z]:[\\/]|(?<![\w.])\.{0,2}\/)[^\s"':;)]+/i.exec(String(text ?? ''))
357
+ if (match === null) return ''
358
+ // 大小写按平台折叠,和 normDir 同理:在区分大小写的系统上折叠会把 a.js 与 A.js
359
+ // 合成同一个 episode,把两个不同文件各错一次误报成「同一个报错吃了两次」。
360
+ return foldCase(match[0].replace(/\\/g, '/').replace(/\d+/g, '<n>'))
361
+ }
362
+
363
+ /** 从 tool/result 的事件数据里拔出人能读的错误摘要。 */
364
+ function errorTextOf(data) {
365
+ const message = data?.message
366
+ const parts = []
367
+ if (typeof message?.content === 'string') parts.push(message.content)
368
+ else if (Array.isArray(message?.content)) {
369
+ for (const block of message.content) {
370
+ if (block && typeof block.text === 'string') parts.push(block.text)
371
+ }
372
+ }
373
+ if (data?.error && typeof data.error.message === 'string') parts.push(data.error.message)
374
+ return parts.join('\n').trim()
375
+ }
376
+
377
+ /** 结果文本 → 退出码。ops_bash 把 `[exit code: N]` 写在正文里。 */
378
+ export function exitCodeOf(text) {
379
+ const match = /\[exit code:\s*(-?\d+)\]/i.exec(String(text ?? ''))
380
+ if (match !== null) return Number(match[1])
381
+ const alternate = /\bexit(?:ed)?\s+(?:with\s+)?(?:code|status)\s*[:=]?\s*(-?\d+)/i.exec(String(text ?? ''))
382
+ if (alternate !== null) return Number(alternate[1])
383
+ return void 0
384
+ }
385
+
386
+ function oneLine(text, limit) {
387
+ const flat = String(text ?? '').replace(/\s+/g, ' ').trim()
388
+ return flat.length <= limit ? flat : `${flat.slice(0, limit - 1)}…`
389
+ }
390
+
391
+ /**
392
+ * 解析 SKILL.md:frontmatter 只取 description,正文原样作为 content。
393
+ * 和 dsh-skill-office 的 parseSkill 同形,但**不引 yaml 依赖**——
394
+ * 只认「description: xxx」这一行的最小正则,因为我们自己写这个文件、格式可控。
395
+ * 一旦用户换成带多行 YAML(description: |)的版本,退化为「整段 frontmatter 当描述」也比炸掉强。
396
+ */
397
+ function parseBundledSkill(raw, path) {
398
+ const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/u.exec(raw)
399
+ if (frontmatter?.[1] === undefined) throw new Error(`no YAML frontmatter in ${path}`)
400
+ const block = frontmatter[1]
401
+ let description = ''
402
+
403
+ // 单行 description:"..." 或 '...' 或裸值
404
+ const inline = /^description:\s*(.+)$/m.exec(block)
405
+ if (inline?.[1] !== undefined) {
406
+ description = inline[1].trim()
407
+ const quoted = /^(["'])([\s\S]*)\1$/.exec(description)
408
+ if (quoted?.[2] !== undefined) {
409
+ // 反转义:YAML 双引号串里 \" 与 \\ 是转义,单引号里 '' 是转义
410
+ description =
411
+ quoted[1] === '"'
412
+ ? quoted[2].replace(/\\"/g, '"').replace(/\\\\/g, '\\')
413
+ : quoted[2].replace(/''/g, "'")
414
+ }
415
+ }
416
+
417
+ // 块标量 description: | — 取到下一个非缩进行为止
418
+ if (description.length === 0) {
419
+ const blockStyle = /^description:\s*[|>][-+]?\s*$/m.exec(block)
420
+ if (blockStyle !== null) {
421
+ const after = block.slice(blockStyle.index + blockStyle[0].length)
422
+ const lines = []
423
+ for (const line of after.split(/\r?\n/)) {
424
+ if (line.length === 0) {
425
+ lines.push('')
426
+ continue
427
+ }
428
+ if (!/^\s/.test(line)) break
429
+ lines.push(line.trim())
430
+ }
431
+ description = lines.join(' ').trim()
432
+ }
433
+ }
434
+
435
+ if (description.length === 0) throw new Error(`no description in ${path}`)
436
+ const body = raw.slice(frontmatter[0].length).trim()
437
+ if (body.length === 0) throw new Error(`empty body in ${path}`)
438
+ return { description, body }
439
+ }
440
+
441
+ /**
442
+ * 把 assets/stuck-gate/SKILL.md 注册成 bundled 技能。
443
+ *
444
+ * 为什么 rank 用 600(= BUNDLED_SKILL_RANK):`~/.dsh/skills` 是 USER_DSH_RANK=400,
445
+ * 数值小的优先。用户自己放了一份同名技能时,他那份说话——这是对的,
446
+ * 他显式覆盖了我们的默认文案。只有他没放,才用打包的这份。
447
+ */
448
+ function registerBundledSkill(ctx, log) {
449
+ const skills = ctx.skills
450
+ if (skills === undefined || skills === null || typeof skills.registerProvider !== 'function') {
451
+ log('skills service absent, bundled skill not registered')
452
+ return
453
+ }
454
+
455
+ const directory = join(ASSET_ROOT, BUNDLED_SKILL_NAME)
456
+ const locator = join(directory, 'SKILL.md')
457
+ const resourceBase = directory.split(sep).join('/')
458
+
459
+ // 启动时就解析一次:文件缺了/坏了应该在 apply 期就留痕,而不是等模型来调。
460
+ const parsed = parseBundledSkill(readFileSync(locator, 'utf8'), locator)
461
+ const candidate = {
462
+ name: BUNDLED_SKILL_NAME,
463
+ description: parsed.description,
464
+ invocation: { modelInvocable: true, userInvocable: true },
465
+ provider: name,
466
+ source: 'bundled',
467
+ rank: BUNDLED_SKILL_RANK,
468
+ resourceBase: { kind: 'directory', path: resourceBase },
469
+ locator
470
+ }
471
+ let cachedBody = parsed.body
472
+
473
+ const provider = {
474
+ name,
475
+ list: () => Promise.resolve([candidate]),
476
+ async get(_candidate, options) {
477
+ // get 支持 signal;重读文件让用户改 assets 里的文案后无需重启。
478
+ try {
479
+ const raw = await readFile(locator, { encoding: 'utf8', signal: options?.signal })
480
+ cachedBody = parseBundledSkill(raw, locator).body
481
+ } catch (error) {
482
+ // 读不到就退回启动时那份,别让一次 IO 抖动把技能变成不可用。
483
+ if (options?.signal?.aborted === true) throw error
484
+ }
485
+ const { rank: _rank, locator: _locator, ...summary } = candidate
486
+ return { ...summary, content: cachedBody }
487
+ }
488
+ }
489
+
490
+ // 把 disposer 交回去:ctx.inject 的回调可能因为服务换代而重跑,
491
+ // 重跑时不先摘掉上一代就会在 catalog 里堆出同名 provider。
492
+ log(`bundled skill registered: ${BUNDLED_SKILL_NAME} <- ${locator}`)
493
+ return ctx.skills.registerProvider(() => provider)
494
+ }
495
+
496
+ export function apply(ctx, config) {
497
+ const cfg = normalizeConfig(config)
498
+
499
+ // 落盘失败只 warn 一次:目录不可写(权限、只读盘、路径写错)时,
500
+ // 每次事件都 warn 会把 stdout 刷爆;一次不说又会变成「插件装了但面板永远空着」
501
+ // 这种最难查的状态。
502
+ let warnedLogFailure = false
503
+ const record = async (line) => {
504
+ if (cfg.logFile.length === 0) return
505
+ try {
506
+ await mkdir(dirname(cfg.logFile), { recursive: true })
507
+ await appendFile(cfg.logFile, `${new Date().toISOString()} ${line}\n`, 'utf8')
508
+ } catch (error) {
509
+ if (warnedLogFailure) return
510
+ warnedLogFailure = true
511
+ try {
512
+ ctx.logger?.warn?.(
513
+ `better-debug: 写不进日志 ${cfg.logFile}(${error?.code ?? error?.message ?? error});` +
514
+ '闸门仍然工作,但面板和事后验收都看不到数据。把 logFile 指到一个可写目录,或设为 "" 显式关闭。'
515
+ )
516
+ } catch {}
517
+ }
518
+ }
519
+
520
+ if (!cfg.enabled) {
521
+ void record('disabled by config, no gate installed')
522
+ return
523
+ }
524
+
525
+ // 把自带的 stuck-gate 技能注册进 catalog,否则别人装了这个插件,
526
+ // 注入文本末尾那句「完整五条:skill `stuck-gate`」就是指向空气。
527
+ //
528
+ // 但 `skills` 服务不是所有宿主都有(见文件顶 inject 的注释),所以这里
529
+ // 动态订阅:服务在就注册,不在就只是少一个可选功能。
530
+ // 整段包 try/catch:技能注册失败(老版本 DSH、用户自己放了一份同名技能)
531
+ // 不该让闸门本身失效。
532
+ const mountSkill = (skillCtx) => {
533
+ try {
534
+ registerBundledSkill(skillCtx ?? ctx, (line) => void record(line))
535
+ } catch (error) {
536
+ void record(`skill register failed: ${error?.message ?? error}`)
537
+ }
538
+ }
539
+ try {
540
+ if (typeof ctx.inject === 'function') ctx.inject(['skills'], mountSkill)
541
+ else mountSkill(ctx)
542
+ } catch (error) {
543
+ void record(`skill register failed: ${error?.message ?? error}`)
544
+ }
545
+
546
+ // 每次热重载/启动都留一行,验收靠它判断「插件到底加载了没有」。
547
+ // ctx.logger 只进 Electron 主进程 stdout,事后没法 grep,所以必须有落盘旁路。
548
+ void record(
549
+ `apply pid=${process.pid} logFile=${cfg.logFile} ` +
550
+ `A=${cfg.repeatEditThreshold} B=${cfg.repeatErrorThreshold} C=${cfg.noVerifySteps} ` +
551
+ `budget=${cfg.maxInjectsPerTurn} window=${cfg.changedWindow} panel=${cfg.panel}`
552
+ )
553
+
554
+ // 面板:只读视图,挂 /better-debug。
555
+ // 用动态注入而不是加进 `export const inject` —— 后者是结构性变更,
556
+ // 热重载会失败、且会让没有 webServer 的宿主连闸门都装不上。
557
+ // 注意 mount 必须用注入回调收到的子 ctx:cordis 里没 inject 的 ctx 读服务会抛
558
+ // `cannot get property "webServer" without inject`,外层 ctx 是拿不到 webServer 的。
559
+ if (cfg.panel) {
560
+ const mount = (webCtx) => {
561
+ try {
562
+ registerPanel(webCtx ?? ctx, () => cfg)
563
+ } catch (error) {
564
+ void record(`panel register failed: ${error?.message ?? error}`)
565
+ }
566
+ }
567
+ try {
568
+ if (typeof ctx.inject === 'function') ctx.inject(['webServer'], mount)
569
+ else mount(ctx)
570
+ } catch (error) {
571
+ void record(`panel unavailable: ${error?.message ?? error}`)
572
+ }
573
+ }
574
+
575
+ /** session → 本 turn 的全部观测。turn/start 重置。 */
576
+ const state = new Map()
577
+
578
+ const fresh = (turn) => ({
579
+ turn,
580
+ /** 本 turn 累计编辑次数(按路径),只用于日志的 worstEdits。 */
581
+ edits: new Map(),
582
+ /**
583
+ * 连续盲改:自上次**测量结果**以来对同一路径的编辑次数。
584
+ * 一次测量结果返回就清零(或只清它管得到的那些路径)——有回路的收敛不该算打转。
585
+ */
586
+ streakEdits: new Map(),
587
+ /** 自上次测量以来的写入次数(不分路径)——C 的 arm 依据。 */
588
+ writesSinceMeasure: 0,
589
+ /** 已满足「N 步没测量」:只上膛,不开口。 */
590
+ measureArmed: false,
591
+ /** 上膛之后真的又写了一次 —— 这时才该说话。 */
592
+ wroteWhileArmed: false,
593
+ lastEditStep: void 0,
594
+ lastEditLabel: void 0,
595
+ /** 最近一次测量:{tool, ok, exit, atStep},注入文本与日志都用它。 */
596
+ lastMeasure: void 0,
597
+ pendingStep: void 0,
598
+ /** callId → {name, args, measure}:结果回来时才知道该不该清零。 */
599
+ calls: new Map(),
600
+ /** episode key → {count, sample, tool, target, firstClock}。 */
601
+ errors: new Map(),
602
+ /** 单调时钟:工具调用/报错/搜索/测量各推进一格,用来判「搜索是否晚于 episode」。 */
603
+ clock: 0,
604
+ lastSearchClock: 0,
605
+ searchedThisTurn: false,
606
+ writeSeq: 0,
607
+ errorSeq: 0,
608
+ /** 本 turn 每个信号已说过的次数(测量后递减,实现重新武装)。 */
609
+ fired: { A: 0, B: 0, C: 0 },
610
+ injectionsThisTurn: 0,
611
+ /** 上次提醒时的 {writeSeq, errorSeq};两者都没变说明白提醒了。 */
612
+ lastFireMark: void 0,
613
+ /** 最近一次动作 {name, cls},注入时记进 outcome 的 before=。 */
614
+ lastAction: void 0,
615
+ quiet: false,
616
+ turnUserText: '',
617
+ /** 交付态:present **成功返回**之后置 true,下一次写入重新置 false。 */
618
+ done: false,
619
+ /**
620
+ * 注入后等着的收尾:每条注入一个 pending,只记第一条后续动作(立刻落盘),
621
+ * 再在窗口内盯第一个真正的转向动作(verify/search)落一条 change 行。
622
+ */
623
+ pendings: []
624
+ })
625
+
626
+ const stateFor = (session) => {
627
+ let s = state.get(session)
628
+ if (s === void 0) {
629
+ s = fresh(void 0)
630
+ state.set(session, s)
631
+ }
632
+ return s
633
+ }
634
+
635
+ /** 插件可能在本 turn 中途热加载而错过 turn/start,此时也要开始记账。 */
636
+ const turnState = (session, turn) => {
637
+ const s = stateFor(session)
638
+ if (turn !== void 0 && s.turn !== turn) {
639
+ state.set(session, fresh(turn))
640
+ return state.get(session)
641
+ }
642
+ return s
643
+ }
644
+
645
+ /**
646
+ * 测量结果到达 → 连续盲改状态清零(可选择只清它管得到的路径)。
647
+ *
648
+ * 为什么要按目录过滤:`npm test` 在 `C:/other` 跑完,不能替 `C:/work/src/x.js`
649
+ * 洗白——那道闸门守的是「这个文件改完没测」,别的目录的测试不是它的测量。
650
+ */
651
+ const settleMeasure = (s, { tool, args, ok, exit, atStep }) => {
652
+ const dirs = measureDirs(args)
653
+ let cleared = 0
654
+ if (cfg.decayEditsOnVerify) {
655
+ if (dirs.size === 0) {
656
+ cleared = s.streakEdits.size
657
+ s.streakEdits.clear()
658
+ s.writesSinceMeasure = 0
659
+ } else {
660
+ for (const path of [...s.streakEdits.keys()]) {
661
+ const dir = dirOf(path)
662
+ let hit = false
663
+ for (const candidate of dirs) {
664
+ if (dir === candidate || dir.startsWith(`${candidate}/`) || candidate.startsWith(`${dir}/`)) {
665
+ hit = true
666
+ break
667
+ }
668
+ }
669
+ if (hit) {
670
+ s.streakEdits.delete(path)
671
+ cleared += 1
672
+ }
673
+ }
674
+ if (s.streakEdits.size === 0) s.writesSinceMeasure = 0
675
+ }
676
+ // 上膛状态也一起解除:刚刚测过,C 的前提没了。
677
+ if (s.streakEdits.size === 0) {
678
+ s.measureArmed = false
679
+ s.wroteWhileArmed = false
680
+ }
681
+ }
682
+ s.lastMeasure = { tool, ok, exit, atStep }
683
+ // 拿到新事实 → 重新武装:同一长 turn 的另一个阶段再犯,值得再说一次。
684
+ s.fired.A = 0
685
+ s.fired.C = 0
686
+ s.clock += 1
687
+ return cleared
688
+ }
689
+
690
+ ctx.on('session/event', (session, event) => {
691
+ if (event === null || event === void 0) return
692
+ const data = event.data ?? {}
693
+ if (event.type === 'turn/start') {
694
+ state.set(session, fresh(data.turn))
695
+ return
696
+ }
697
+ if (event.type === 'turn/end') {
698
+ const s = state.get(session)
699
+ if (s !== void 0 && (s.turn === void 0 || s.turn === data.turn)) state.delete(session)
700
+ return
701
+ }
702
+ if (event.type === 'user/message') {
703
+ // 只认真正的人话(source.kind === 'user'),插件自己注入的不算。
704
+ const source = data.source ?? {}
705
+ if (source.kind !== 'user') return
706
+ const blocks = Array.isArray(data.content) ? data.content : []
707
+ const text = blocks
708
+ .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
709
+ .map((block) => block.text)
710
+ .join('\n')
711
+ if (text.length === 0) return
712
+ const s = stateFor(session)
713
+ s.turnUserText = text
714
+ // 用户明确说「别搜/直接改」→ 整 turn 静音(D 段例外)。
715
+ if (QUIET_PATTERN.test(text)) s.quiet = true
716
+ return
717
+ }
718
+ if (event.type === 'tool/call') {
719
+ const s = stateFor(session)
720
+ const args = data.arguments !== null && typeof data.arguments === 'object' ? data.arguments : {}
721
+ const measure = isMeasurement(data.name, args, cfg)
722
+ const cls = classifyTool(data.name, measure)
723
+ if (typeof data.callId === 'string' && typeof data.name === 'string') {
724
+ s.calls.set(data.callId, { name: data.name, args, measure })
725
+ }
726
+ s.clock += 1
727
+
728
+ // 注入后第一条工具调用,就是「模型听没听」的第一层证据。
729
+ // 记下来、当场收尾:只收第一条,晚到的动作不能把早先的原地打转盖掉。
730
+ const at = Number(data.step)
731
+ const stepNow = Number.isFinite(at) ? at : void 0
732
+ for (const pending of s.pendings) {
733
+ if (pending.firstSeen === false && typeof data.name === 'string') {
734
+ pending.firstSeen = true
735
+ pending.first = { name: data.name, cls }
736
+ void record(
737
+ `outcome session=${session.id} turn=${pending.turn} inj=${pending.inj} after=${pending.tag} ` +
738
+ `first=${data.name} class=${cls} steps=${stepNow === void 0 ? 0 : Math.max(0, stepNow - pending.atStep)} ` +
739
+ `before=${pending.before?.name ?? '-'}`
740
+ )
741
+ }
742
+ // 第二层:窗口内第一个真正的转向动作(验证 / 搜索)。中位步数都从这算。
743
+ if (pending.changed === false && (cls === 'verify' || cls === 'search') && typeof data.name === 'string') {
744
+ pending.changed = true
745
+ void record(
746
+ `change session=${session.id} turn=${pending.turn} inj=${pending.inj} after=${pending.tag} ` +
747
+ `tool=${data.name} class=${cls} steps=${stepNow === void 0 ? 0 : Math.max(0, stepNow - pending.atStep)}`
748
+ )
749
+ }
750
+ }
751
+ // 收掉已经看过第一动作、又超出窗口的 pending;窗口内继续等转向。
752
+ s.pendings = s.pendings.filter(
753
+ (pending) =>
754
+ pending.firstSeen === false ||
755
+ (pending.changed === false && stepNow !== void 0 && stepNow <= pending.atStep + cfg.changedWindow)
756
+ )
757
+
758
+ s.lastAction = { name: data.name, cls }
759
+ // 交付态:present **结果成功后**才休眠;调用发起就休眠会把失败的 present 当交付。
760
+ if (SEARCH_TOOLS.has(data.name)) {
761
+ s.searchedThisTurn = true
762
+ s.lastSearchClock = s.clock
763
+ // 搜索是外部先验,和测量同级:重新武装 A / C。
764
+ s.fired.A = 0
765
+ s.fired.C = 0
766
+ }
767
+ return
768
+ }
769
+ if (event.type === 'tool/result') {
770
+ const s = stateFor(session)
771
+ const callId = data.message?.source?.callId
772
+ const call = typeof callId === 'string' ? s.calls.get(callId) : void 0
773
+ const toolName = call?.name ?? (typeof callId === 'string' ? s.calls.get(callId) : void 0)
774
+ const text = errorTextOf(data)
775
+ const isError = data.message?.isError === true || data.error !== void 0
776
+ s.clock += 1
777
+
778
+ // 测量必须**等到结果**才清零:发起就清零等于把「打算测」当成「测过了」。
779
+ if (call !== void 0 && call.measure === true) {
780
+ const exit = exitCodeOf(text)
781
+ const ok = isError !== true && (exit === void 0 || exit === 0)
782
+ const cleared = settleMeasure(s, {
783
+ tool: call.name,
784
+ args: call.args,
785
+ ok,
786
+ exit,
787
+ atStep: Number(data.step)
788
+ })
789
+ void record(
790
+ `measure session=${session.id} turn=${s.turn ?? '-'} tool=${call.name} ok=${ok} ` +
791
+ `exit=${exit === void 0 ? '-' : exit} cleared=${cleared}`
792
+ )
793
+ if (typeof callId === 'string') s.calls.delete(callId)
794
+ // 失败的测试也是有效测量:它给了新事实,不该继续算「盲改」。所以这里不 return。
795
+ }
796
+ // 交付态:present 的结果回来了,且不是报错 —— 现在才算交付完成。
797
+ if (call?.name === 'present' && isError !== true) {
798
+ s.done = true
799
+ if (typeof callId === 'string') s.calls.delete(callId)
800
+ return
801
+ }
802
+ if (!isError) {
803
+ if (typeof callId === 'string') s.calls.delete(callId)
804
+ return
805
+ }
806
+ if (text.length === 0) return
807
+ const fingerprint = errorFingerprint(text)
808
+ const target = errorTargetOf(text)
809
+ const tool = call?.name ?? 'tool'
810
+ const key = `${tool}|${target}|${fingerprint}`
811
+ const prev = s.errors.get(key)
812
+ s.errorSeq += 1
813
+ if (prev === void 0) {
814
+ s.errors.set(key, {
815
+ count: 1,
816
+ sample: oneLine(text, 160),
817
+ tool,
818
+ target,
819
+ firstClock: s.clock
820
+ })
821
+ } else {
822
+ prev.count += 1
823
+ prev.lastClock = s.clock
824
+ // 同一个 episode 又被搜索过 → 重新武装,允许再说一次。
825
+ if (s.lastSearchClock > prev.firstClock) s.fired.B = Math.max(0, s.fired.B - 1)
826
+ }
827
+ if (typeof callId === 'string') s.calls.delete(callId)
828
+ }
829
+ })
830
+
831
+ ctx.on('session/disposed', (session) => {
832
+ state.delete(session)
833
+ })
834
+
835
+ // 同一文件反复改:只认写入意图,不认「读」。prepend 保证在别的消费者之前拿到原始 target。
836
+ ctx.on('fs/write-intent', async (target, actor, next) => {
837
+ const intent = await next()
838
+ try {
839
+ const session = actor === null || actor === void 0 ? void 0 : actor.agent?.session
840
+ if (session === void 0 || session === null) return intent
841
+ const abs = targetPath(target)
842
+ if (abs === void 0) return intent
843
+ if (!isAbsPath(abs)) return intent
844
+ // 生成物 / 锁文件 / 日志不算盲改:改它们本来就不该触发「你有没有测」。
845
+ if (cfg.excludePaths.test(abs.replace(/\\/g, '/'))) return intent
846
+ const s = stateFor(session)
847
+ s.edits.set(abs, (s.edits.get(abs) ?? 0) + 1)
848
+ s.streakEdits.set(abs, (s.streakEdits.get(abs) ?? 0) + 1)
849
+ s.writesSinceMeasure += 1
850
+ s.writeSeq += 1
851
+ // 上膛之后又动手了 —— C 的开口条件就是这一下。
852
+ if (s.measureArmed) s.wroteWhileArmed = true
853
+ // 又开始改了 → 交付态解除,闸门重新武装。
854
+ s.done = false
855
+ // 「上一条动作」也要算上写入本身:写入走的是 fs/write-intent,
856
+ // 不一定有对应的 tool/call(直接写文件、别的插件代写都会这样)。
857
+ // 不记这一步的话,注入行的 before= 会空成 '-',面板就没法说「从改转到了测」。
858
+ s.lastAction = { name: 'write', cls: 'edit' }
859
+ // 写入发生在某一步内部,此刻 pre-step 已记下该步号;热加载没赶上就当本步。
860
+ s.lastEditStep = Number.isFinite(s.pendingStep) ? s.pendingStep : 0
861
+ s.lastEditLabel = abs
862
+ } catch {}
863
+ return intent
864
+ }, { prepend: true })
865
+
866
+ ctx.on('agent/pre-step', async ({ agent, turn, step, signal }, next) => {
867
+ const decision = await next()
868
+ try {
869
+ if (decision.kind === 'reject') return decision
870
+ if (signal?.aborted) return decision
871
+ const session = agent?.session
872
+ if (session === null || session === void 0) return decision
873
+ if (!eligible(session)) return decision
874
+
875
+ const s = turnState(session, turn)
876
+ // 写入发生在 step 内部,所以这里把当前 step 记下来给 write-intent 用。
877
+ s.pendingStep = step
878
+
879
+ if (s.quiet) return decision
880
+ // 交付态:present 已成功,且之后没有新的写入 →
881
+ // 本轮没有「下一次尝试」,闸门不该再落(修掉「结论 → 一串工具调用」倒挂)。
882
+ // 留一行 suppress,让「闸门醒着但故意不出声」和「闸门根本没挂上」可区分。
883
+ if (cfg.doneOnPresent && s.done) {
884
+ if (!s.fired.done) {
885
+ s.fired.done = 1
886
+ void record(`suppress session=${session.id} turn=${turn} step=${step} reason=done`)
887
+ }
888
+ return decision
889
+ }
890
+
891
+ // 上一次提醒之后既没多写一次、也没多吃一个错 —— 再说一遍只是噪音。
892
+ // 模型需要的是「新事实」,不是「更严厉的同一句话」。
893
+ if (
894
+ s.lastFireMark !== void 0 &&
895
+ s.lastFireMark.writeSeq === s.writeSeq &&
896
+ s.lastFireMark.errorSeq === s.errorSeq
897
+ ) {
898
+ return decision
899
+ }
900
+
901
+ // C 的上膛:改完 N 步没测量,**只上膛不开口**。阅读和思考不该被打断,
902
+ // 只有「上膛之后又动手」才说明它要带着没有回路的状态继续改。
903
+ if (
904
+ Number.isFinite(s.lastEditStep) &&
905
+ !s.measureArmed &&
906
+ s.streakEdits.size > 0 &&
907
+ step - s.lastEditStep >= cfg.noVerifySteps
908
+ ) {
909
+ s.measureArmed = true
910
+ void record(`arm session=${session.id} turn=${turn} step=${step} gap=${step - s.lastEditStep}`)
911
+ }
912
+
913
+ if (s.injectionsThisTurn >= cfg.maxInjectsPerTurn) return decision
914
+
915
+ const signals = []
916
+
917
+ // A:同一文件「自上次测量以来」连续改了 N 次。
918
+ if (s.fired.A < 1) {
919
+ let worstPath
920
+ let worst = 0
921
+ for (const [path, count] of s.streakEdits) {
922
+ if (count > worst) {
923
+ worst = count
924
+ worstPath = path
925
+ }
926
+ }
927
+ if (worst >= cfg.repeatEditThreshold) {
928
+ const base = worstPath.split(/[/\\]+/).pop() ?? worstPath
929
+ signals.push({ kind: 'A', n: worst, detail: `(${base})` })
930
+ }
931
+ }
932
+
933
+ // B:同一个 error episode(工具 + 目标 + 指纹)重复,且这个 episode 之后没搜过。
934
+ if (s.fired.B < 1) {
935
+ let worst
936
+ for (const entry of s.errors.values()) {
937
+ if (entry.count < cfg.repeatErrorThreshold) continue
938
+ if (s.lastSearchClock > entry.firstClock) continue
939
+ if (worst === void 0 || entry.count > worst.count) worst = entry
940
+ }
941
+ if (worst !== void 0) {
942
+ signals.push({ kind: 'B', n: worst.count, detail: `报错:${worst.sample}` })
943
+ }
944
+ }
945
+
946
+ // C:上膛之后又写了一次,仍然没有测量。
947
+ if (s.fired.C < 1 && s.measureArmed && s.wroteWhileArmed) {
948
+ const gap = Number.isFinite(s.lastEditStep) ? Math.max(0, step - s.lastEditStep) : 0
949
+ signals.push({ kind: 'C', n: gap })
950
+ }
951
+
952
+ if (signals.length === 0) return decision
953
+
954
+ for (const signal of signals) s.fired[signal.kind] += 1
955
+ // A/B 已经说明了局面;同一句话再补一句「改完没测量」只是换个说法。
956
+ if (signals.some((signal) => signal.kind !== 'C')) s.fired.C += 1
957
+ s.wroteWhileArmed = false
958
+ s.injectionsThisTurn += 1
959
+ s.lastFireMark = { writeSeq: s.writeSeq, errorSeq: s.errorSeq }
960
+
961
+ const text = messageText(signals)
962
+ const tag = signals.map((signal) => signal.kind).join('+')
963
+ const inj = createHash('sha256')
964
+ .update(`${session.id}|${turn}|${step}|${tag}|${s.injectionsThisTurn}`)
965
+ .digest('hex')
966
+ .slice(0, 8)
967
+ // 埋点:等注入之后的第一条工具调用 / 第一个转向动作。
968
+ // 放在 lastFireMark 之后:这次注入确实发生了,才值得收结果。
969
+ s.pendings.push({
970
+ inj,
971
+ tag,
972
+ turn,
973
+ atStep: Number(step),
974
+ before: s.lastAction,
975
+ firstSeen: false,
976
+ first: void 0,
977
+ changed: false
978
+ })
979
+
980
+ try {
981
+ ctx.logger?.info?.(
982
+ `dsh-better-debug: inject session=${session.id} turn=${turn} step=${step} signals=${tag}`
983
+ )
984
+ } catch {}
985
+ // 日志是唯一的验收面。A 按 streakEdits 判定,必须把那个数单独写出来;
986
+ // worstEdits 仍是本 turn 累计次数(面板沿用,不改形状)。
987
+ let worstEdits = 0
988
+ for (const count of s.edits.values()) if (count > worstEdits) worstEdits = count
989
+ let worstStreak = 0
990
+ for (const count of s.streakEdits.values()) if (count > worstStreak) worstStreak = count
991
+ let worstErrors = 0
992
+ let errorSample = ''
993
+ for (const entry of s.errors.values()) {
994
+ if (entry.count > worstErrors) {
995
+ worstErrors = entry.count
996
+ errorSample = entry.sample
997
+ }
998
+ }
999
+ await record(
1000
+ `inject session=${session.id} turn=${turn} step=${step} signals=${tag} inj=${inj} ` +
1001
+ `chars=${text.length} tokens=${estimateTokens(text)} ` +
1002
+ `files=${s.edits.size} worstEdits=${worstEdits} worstStreak=${worstStreak} ` +
1003
+ `worstErrors=${worstErrors} ` +
1004
+ `searched=${s.searchedThisTurn} ` +
1005
+ `measured=${s.lastMeasure === void 0 ? 'no' : `yes:${s.lastMeasure.tool}:${s.lastMeasure.ok ? 'ok' : 'fail'}`}` +
1006
+ (errorSample ? ` sample=${JSON.stringify(errorSample.slice(0, 80))}` : '')
1007
+ )
1008
+
1009
+ return {
1010
+ ...decision,
1011
+ messages: [
1012
+ ...decision.messages,
1013
+ {
1014
+ id: randomUUID(),
1015
+ role: 'user',
1016
+ content: [{ type: 'text', text }],
1017
+ // 自报家门,便于 UI 折叠与去重;必须是稳定的 kind 字符串。
1018
+ source: { kind: 'dsh-better-debug' }
1019
+ }
1020
+ ]
1021
+ }
1022
+ } catch (error) {
1023
+ try {
1024
+ ctx.logger?.warn?.(`dsh-better-debug: pre-step error: ${error?.message ?? error}`)
1025
+ } catch {}
1026
+ return decision
1027
+ }
1028
+ }, { prepend: true })
1029
+ }
1030
+
1031
+ export default { name, inject, apply }