dsh-workplan 2.3.9 → 3.0.0

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.
@@ -6,6 +6,22 @@
6
6
  * 2. 再全面、深入思考,整理出能完美完成自身工作的完整、可执行思路;
7
7
  * 3. 只有前两步完成后,才按思路执行与验证。
8
8
  * 全过程按先后顺序分为三个阶段:规划阶段 → 执行阶段 → 验证阶段。
9
+ *
10
+ * [2.5.1] 两轮深度思考协议(用户 2026-11-11 强制要求,底层机制升级):
11
+ * 部门负责人、部门里相关领域的全球顶尖专家,分别在执行自己的
12
+ * 任务时,必须——
13
+ * 第一轮:先全面、全盘、深入梳理、研究、思考自己的任务(→ problemAnalysis);
14
+ * 第二轮:基于第一轮完成好的所有结果,再全面、全盘、深入地开展梳理、研究
15
+ * 和思考,理清自己的思路,理清自己该具体如何一步步执行、达到最终
16
+ * 完美完成自己任务的方法、流程和步骤(→ approach),并把第二轮如何
17
+ * 基于第一轮全部结果的依据对应写清(→ approachBasis,新增必填证据);
18
+ * 执行:最后,基于第二轮理清楚的所有方法、流程、步骤,开始具体的执行工作。
19
+ * 三轮顺序与依赖不可颠倒:第二轮必须消费第一轮的全部结果,执行必须消费第二
20
+ * 轮的方法、流程、步骤。approachBasis 让「基于前一步完成好的所有结果」这条
21
+ * 依赖成为可审计的结构化证据,而不是一句提示词——缺依据的结果无法记 done。
22
+ * 本协议对三层执行者同一口径:二级任务书(buildChildPrompt)与三级任务书
23
+ * (buildDelegateePrompt)都注入本模块的 threePhasePromptLines,结算门禁
24
+ * (validatePhaseEvidence)与负责人再分配门禁(planDelegations)同判据。
9
25
  * 阶段三允许用 dsh_workplan_verify 核验;缺 planning/execution 证据时返回 PHASE_GATE。
10
26
  * 注意(2.0.2 更正):2026-11-05 的「第一、二阶段禁用插件」只是当次优化会话的
11
27
  * 过程约束,不是对所有后续会话的产品规则;插件不全局禁用。
@@ -22,17 +38,23 @@
22
38
  */
23
39
 
24
40
  import { type Retrospective, validateRetrospective } from './lessons.js'
41
+ // [3.0.0] Dice 单一真源在 v3-contract(零依赖,无循环):
42
+ // plan.ts#criterionSimilarity 与这里的 missingCriteria 都用它。
43
+ import { diceSimilarity } from './v3-contract.js'
25
44
 
26
45
  /** 三阶段顺序不可颠倒;这里也是结果块里 `phases` 的键名。 */
27
46
  export const THREE_PHASE_IDS = Object.freeze(['planning', 'execution', 'verification'] as const)
28
- export const THREE_PHASE_VERSION = 1
47
+ /** [2.5.1] 契约版本 2:规划阶段升级为两轮深度思考协议(新增必填 approachBasis)。 */
48
+ export const THREE_PHASE_VERSION = 2
29
49
 
30
50
  /**
31
- * 「全面、深入」无法由代码度量,但可以给一个不可忽略的下限:
32
- * 问题梳理与可执行思路各至少 40 个字符,避免一个词就冒充规划。
51
+ * 「全面、全盘、深入」无法由代码度量,但可以给一个不可忽略的下限:
52
+ * 第一轮任务深研与第二轮方法、流程、步骤各至少 40 个字符,避免一个词就冒充
53
+ * 规划;第二轮依据(approachBasis)至少 20 个字符,避免一句空话冒充依赖对应。
33
54
  */
34
55
  export const MIN_PLANNING_PROBLEM_CHARS = 40
35
56
  export const MIN_PLANNING_APPROACH_CHARS = 40
57
+ export const MIN_PLANNING_BASIS_CHARS = 20
36
58
  export const MAX_PHASE_LIST_ITEMS = 20
37
59
  export const MAX_PHASE_ITEM_CHARS = 800
38
60
  export const MAX_PHASE_TOTAL_CHARS = 6000
@@ -44,10 +66,18 @@ export type PhaseCheck = {
44
66
  }
45
67
 
46
68
  export type PlanningPhase = {
69
+ /** [2.5.1] 第一轮 · 任务深研:全面、全盘、深入梳理、研究、思考自己的任务的结果。 */
47
70
  problemAnalysis: string[]
48
71
  constraints: string[]
49
72
  unknowns: string[]
73
+ /** [2.5.1] 第二轮 · 基于第一轮全部结果理清的方法、流程、步骤(一步步执行的路径)。 */
50
74
  approach: string[]
75
+ /**
76
+ * [2.5.1] 第二轮依据(必填):第二轮思考如何「基于刚才前一步完成好的所有
77
+ * 结果」——逐条写清第一轮的哪些事实/约束/矛盾决定了第二轮的哪些方法/流程/
78
+ * 步骤。缺它则两轮之间的依赖不可审计,规划阶段判未完成。
79
+ */
80
+ approachBasis: string[]
51
81
  }
52
82
 
53
83
  export type ExecutionPhase = {
@@ -120,12 +150,16 @@ function totalChars(items: string[]) {
120
150
  }
121
151
 
122
152
  /**
123
- * Same matching rules as `src/plan.ts#acceptanceCoverage` (Q6 / U-16):
124
- * stable A1…An numbering, exact full text, or a longer text containing the
125
- * full criterion. A partial copy must not count as coverage.
153
+ * Same matching rules as `src/plan.ts#acceptanceCoverage` (Q6 / U-16 +
154
+ * [2.0.4] 同义改写两条宽松规则,逐字对齐 plan.ts:3177-3202):
155
+ * stable A1…An numbering, exact full text, a longer text containing the
156
+ * full criterion, a near-full copy (≥85% of the criterion length), or a
157
+ * paraphrase with Dice ≥ 0.70 and matching negation polarity. A partial
158
+ * copy must not count as coverage.
126
159
  *
127
160
  * Kept local to avoid importing plan.ts (which imports this module); the
128
- * rules are pinned by tests on both sides.
161
+ * rules are pinned by tests on both sides. Dice itself is shared via the
162
+ * zero-dependency v3-contract single source (`diceSimilarity`).
129
163
  */
130
164
  function normaliseCriterion(value: any) {
131
165
  return String(value ?? '')
@@ -134,6 +168,11 @@ function normaliseCriterion(value: any) {
134
168
  .replace(/^(必须|需要|应当|应该|请|务必)/, '')
135
169
  }
136
170
 
171
+ /** 与 plan.ts#hasNegation 逐字对齐:否定/禁止语气不一致不允许判覆盖。 */
172
+ function hasNegation(text: string) {
173
+ return /不得|禁止|严禁|不能|不可|不允许|不应|无需|避免|排除|不超过|不低于|不高于|不等于|未通过|未完成/.test(String(text ?? ''))
174
+ }
175
+
137
176
  function missingCriteria(expected: any, checks: PhaseCheck[]) {
138
177
  const want = (Array.isArray(expected) ? expected : []).map(normaliseCriterion)
139
178
  const got = checks.map((check) => normaliseCriterion(check.criterion)).filter(Boolean)
@@ -145,7 +184,11 @@ function missingCriteria(expected: any, checks: PhaseCheck[]) {
145
184
  if (row === criterion) return true
146
185
  if (id.test(row)) return true
147
186
  if (Math.min(row.length, criterion.length) < 6) return false
148
- return row.includes(criterion)
187
+ if (row.includes(criterion)) return true
188
+ // [2.0.4] 宽松规则(与 plan.ts:3199-3201 逐字对齐):
189
+ if (criterion.includes(row) && row.length / criterion.length >= 0.85) return true
190
+ if (hasNegation(criterion) !== hasNegation(row)) return false
191
+ return diceSimilarity(row, criterion) >= 0.7
149
192
  })
150
193
  if (!covered) missing.push(`A${index + 1}`)
151
194
  }
@@ -175,9 +218,9 @@ export function validatePhaseEvidence(value: any, expectedAcceptance: any = []):
175
218
  }
176
219
  }
177
220
  const planningRaw = isRecord(value.planning) ? value.planning : null
178
- if (!planningRaw) fail('planning', 'phases.planning 缺失(阶段一:先梳理问题,再形成可执行思路)')
221
+ if (!planningRaw) fail('planning', 'phases.planning 缺失(阶段一 · 两轮深度思考:先全面、全盘、深入梳理、研究、思考自己的任务,再基于其全部结果理清方法、流程、步骤)')
179
222
  const executionRaw = isRecord(value.execution) ? value.execution : null
180
- if (!executionRaw) fail('execution', 'phases.execution 缺失(阶段二:按阶段一的思路执行)')
223
+ if (!executionRaw) fail('execution', 'phases.execution 缺失(阶段二:基于第二轮理清的方法、流程、步骤执行)')
181
224
  const verificationRaw = isRecord(value.verification) ? value.verification : null
182
225
  if (!verificationRaw) fail('verification', 'phases.verification 缺失(阶段三:逐条验证)')
183
226
 
@@ -192,14 +235,21 @@ export function validatePhaseEvidence(value: any, expectedAcceptance: any = []):
192
235
  required: !!planningRaw,
193
236
  minItems: 1,
194
237
  }),
238
+ approachBasis: readTextList(planningRaw?.approachBasis, 'phases.planning.approachBasis', errors, {
239
+ required: !!planningRaw,
240
+ minItems: 1,
241
+ }),
195
242
  }
196
243
  if (errors.some((item) => item.startsWith('phases.planning.problemAnalysis'))) failedPhase ||= 'planning'
197
244
  if (errors.some((item) => item.startsWith('phases.planning.approach'))) failedPhase ||= 'planning'
198
245
  if (planning.problemAnalysis.length > 0 && totalChars(planning.problemAnalysis) < MIN_PLANNING_PROBLEM_CHARS) {
199
- fail('planning', `phases.planning.problemAnalysis 太薄(合计 ${totalChars(planning.problemAnalysis)} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS} 字):要逐条写清现状、约束、未知与主要矛盾`)
246
+ fail('planning', `phases.planning.problemAnalysis 太薄(合计 ${totalChars(planning.problemAnalysis)} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS} 字):第一轮要全面、全盘、深入梳理、研究、思考自己的任务,逐条写清目标与验收、现状、约束、未知、主要矛盾与边界`)
200
247
  }
201
248
  if (planning.approach.length > 0 && totalChars(planning.approach) < MIN_PLANNING_APPROACH_CHARS) {
202
- fail('planning', `phases.planning.approach 太薄(合计 ${totalChars(planning.approach)} 字,至少 ${MIN_PLANNING_APPROACH_CHARS} 字):要写出完整可执行的步骤,而不是一句目标`)
249
+ fail('planning', `phases.planning.approach 太薄(合计 ${totalChars(planning.approach)} 字,至少 ${MIN_PLANNING_APPROACH_CHARS} 字):第二轮要基于第一轮全部结果理清具体一步步执行、完美完成任务的方法、流程和步骤,而不是一句目标`)
250
+ }
251
+ if (planning.approachBasis.length > 0 && totalChars(planning.approachBasis) < MIN_PLANNING_BASIS_CHARS) {
252
+ fail('planning', `phases.planning.approachBasis 太薄(合计 ${totalChars(planning.approachBasis)} 字,至少 ${MIN_PLANNING_BASIS_CHARS} 字):要写清第二轮的方法、流程、步骤如何基于第一轮梳理、研究、思考完成好的所有结果`)
203
253
  }
204
254
 
205
255
  const execution: ExecutionPhase = {
@@ -276,6 +326,7 @@ export function validatePhaseEvidence(value: any, expectedAcceptance: any = []):
276
326
  ...planning.constraints,
277
327
  ...planning.unknowns,
278
328
  ...planning.approach,
329
+ ...planning.approachBasis,
279
330
  ...execution.steps,
280
331
  ...execution.deviations,
281
332
  verification.requirementCheck,
@@ -302,7 +353,7 @@ export function phaseGateFromErrors(errors: string[]): 'phase-1-2' | 'verificati
302
353
  export function phaseSummaryLine(phases: ThreePhases): string {
303
354
  const deviations = phases.execution.deviations.length
304
355
  return [
305
- `阶段一 规划(问题梳理 ${phases.planning.problemAnalysis.length} 条 / 可执行思路 ${phases.planning.approach.length} 步)`,
356
+ `阶段一 规划 · 两轮深度思考(第一轮任务深研 ${phases.planning.problemAnalysis.length} 条 / 第二轮方法流程步骤 ${phases.planning.approach.length} 步 / 第二轮依据 ${phases.planning.approachBasis.length} 条)`,
306
357
  `阶段二 执行(${phases.execution.steps.length} 步${deviations ? ` / 偏离 ${deviations} 处` : ''})`,
307
358
  `阶段三 验证(${phases.verification.checks.length} 项${phases.verification.allPassed ? ',全部通过' : ',未全部通过'};`
308
359
  + `复盘 ${phases.verification.retrospective.problems.length} 个问题 / `
@@ -320,13 +371,13 @@ export function phaseSummaryLine(phases: ThreePhases): string {
320
371
  */
321
372
  export function threePhasePromptLines(): string[] {
322
373
  return [
323
- '三阶段工作法(用户强制要求;顺序不可颠倒,阶段一没有产出思路之前禁止动手执行):',
324
- '【阶段一 · 规划阶段】',
325
- ' 1) 先全面、深入梳理要解决的问题:逐条写清现状与已知事实、约束条件、未知/待确认项、主要矛盾、工作边界;',
326
- ' 2) 再全面、深入思考,整理出能完美完成本子任务的完整、可执行思路:每一步做什么、产出什么、依赖什么、风险与对策、如何证明做对了;',
327
- ' 3) 自检:任何一条验收标准或用户原要求没有落在思路上,就回到第 1 步重做;思路不完整不得进入阶段二。',
374
+ '三阶段工作法(用户强制要求;顺序不可颠倒,阶段一的两轮深度思考没有完成之前禁止动手执行):',
375
+ '【阶段一 · 规划阶段 = 两轮深度思考(部门负责人、全球顶尖专家执行自己的任务时同一口径,顺序与依赖不可颠倒)】',
376
+ ' 第一轮 · 任务深研:先全面、全盘、深入梳理、研究、思考自己的任务——逐条写清任务目标与验收标准、现状与已知事实、约束条件、未知/待确认项、主要矛盾、工作边界与依赖,结果写入 phases.planning.problemAnalysis;',
377
+ ' 第二轮 · 理清方法流程步骤:基于刚才第一轮完成好的所有结果,再全面、全盘、深入地开展梳理、研究和思考,理清自己的思路,理清自己该具体如何一步步以最高效率执行、确保完美完成自己任务的方法、流程和步骤——每一步做什么、产出什么、依赖什么、风险与对策、如何证明做对了,并写清全程如何少走弯路(先查历史教训记忆、先验证再动手、不重复同样的试错),结果写入 phases.planning.approach;同时把第二轮如何基于第一轮全部结果写入 phases.planning.approachBasis(逐条对应:第一轮的哪些事实/约束/矛盾决定了第二轮的哪些方法/流程/步骤);',
378
+ ' 自检:任何一条验收标准或用户原要求没有落在第二轮的方法、流程、步骤上,就回到第一轮重做;两轮深度思考没有完成并写全(problemAnalysis + approach + approachBasis)之前,不得进入阶段二。',
328
379
  '【阶段二 · 执行阶段】',
329
- ' 严格按阶段一整理出的思路执行。出现新事实需要偏离时,必须记录偏离原因、证据与调整后的做法,不得静默改道。',
380
+ ' 最后,基于刚才第二轮理清楚的所有方法、流程、步骤,开始具体的执行工作:严格按 phases.planning.approach 执行。出现新事实需要偏离时,必须记录偏离原因、证据与调整后的做法,不得静默改道。',
330
381
  '【阶段三 · 验证阶段】',
331
382
  ' 执行完成后逐条验证验收标准与用户原要求:每条都要有可复核的证据(命令输出/文件/引用);验证未通过不得报 done,无法确认写 unverified。',
332
383
  '【阶段三收尾 · 自我学习复盘(强制)】',
@@ -337,8 +388,84 @@ export function threePhasePromptLines(): string[] {
337
388
  ' 4) prevention:以后如何预防再犯,至少 1 条,必须写成「遇到…先…」的可执行硬规则。',
338
389
  ' 插件会在完成判定时复核这四项,并在通过后把复盘写入永久记忆文件;下次派发同类任务时,历史教训会自动出现在提示词里。',
339
390
  '插件使用说明(三阶段证据门禁):',
340
- ' - 阶段一、二:先把问题梳理、可执行思路与执行记录写全;此时不要调用 dsh_workplan_verify,它会因缺少前两阶段证据返回 PHASE_GATE 与待补项(这是证据门禁,不是禁用插件)。',
391
+ ' - 阶段一、二:先把两轮深度思考产物(第一轮任务深研 problemAnalysis、第二轮方法流程步骤 approach、第二轮依据 approachBasis)与执行记录写全;此时不要调用 dsh_workplan_verify,它会因缺少前两阶段证据返回 PHASE_GATE 与待补项(这是证据门禁,不是禁用插件)。',
341
392
  ' - 阶段三:可以调用 dsh_workplan_verify 让插件做最终核验:提交 planning / execution / verification 三阶段证据,插件返回 passed 或仍需补齐的 gaps;未通过先修复再回报。遇阻时可用 dsh_workplan_escalate 上报,它是安全通道,不属于三阶段产物。',
342
393
  ' - 结果块里的 phases 是必填项:缺任一阶段、内容为空、或验证未全部通过,插件都会判为未完成,不能用 done 收尾。',
343
394
  ]
344
395
  }
396
+
397
+ /**
398
+ * [2.5.1] 主 Agent 两轮深度思考协议(用户 2026-11-11 补充要求)。
399
+ *
400
+ * 用户要求:插件底层机制必须确保主 Agent 自己也做到同一协议——执行自己的
401
+ * 任务时,先全面、全盘、深入梳理、研究、思考自己的任务(第一轮),再基于
402
+ * 第一轮完成好的所有结果,再全面、全盘、深入地开展梳理、研究和思考,理清
403
+ * 自己的思路,理清自己该具体如何一步步执行、达到最终完美完成自己任务的
404
+ * 方法、流程和步骤(第二轮),最后基于第二轮理清楚的所有方法、流程、步骤
405
+ * 开始具体的执行工作。
406
+ *
407
+ * 机制落点:主 Agent 的「执行」从派发开始,因此 dsh_workplan_dispatch 首次
408
+ * 派发必须随附 deepThink 产物(本模块校验,与执行者层同一字数下限),未交
409
+ * 或不合格硬拒(MAIN_DEEP_THINK_MISSING / MAIN_DEEP_THINK_INCOMPLETE);
410
+ * 合格后登记到计划记录并 durable 持久化,续跑/重试/重启回放读档放行。
411
+ * 提示词(PROMPT_SECTION)与工具 schema 同步告知,代码守住边界——与部门
412
+ * 层「提示词说服模型,门禁不可绕过」同一设计哲学。
413
+ */
414
+ export type MainDeepThink = {
415
+ /** 第一轮 · 任务深研:全面、全盘、深入梳理、研究、思考自己的任务的结果。 */
416
+ problemAnalysis: string[]
417
+ /** 第二轮 · 基于第一轮全部结果理清的方法、流程、步骤。 */
418
+ approach: string[]
419
+ /** 第二轮依据:第二轮如何基于第一轮完成好的所有结果(逐条对应)。 */
420
+ approachBasis: string[]
421
+ }
422
+
423
+ export type MainDeepThinkValidation = {
424
+ ok: boolean
425
+ code?: 'MAIN_DEEP_THINK_MISSING' | 'MAIN_DEEP_THINK_INCOMPLETE'
426
+ error?: string
427
+ deepThink: MainDeepThink | null
428
+ }
429
+
430
+ /**
431
+ * 主 Agent 两轮思考产物校验(派发硬门禁的唯一判据,与结算门禁同一口径:
432
+ * 第一轮 ≥40 字、第二轮方法流程步骤 ≥40 字、第二轮依据 ≥20 字)。
433
+ * 纯函数:dispatchTool 与测试同口径消费,门禁不能被提示词绕过。
434
+ */
435
+ export function validateMainDeepThink(value: any): MainDeepThinkValidation {
436
+ if (!isRecord(value)) {
437
+ return {
438
+ ok: false,
439
+ code: 'MAIN_DEEP_THINK_MISSING',
440
+ error: '两轮深度思考产物缺失:执行自己的任务必须先全面、全盘、深入梳理、研究、思考自己的任务(第一轮),再基于第一轮完成好的所有结果再全面、全盘、深入地开展梳理、研究和思考,理清具体如何一步步以最高效率、少走弯路、完美完成任务的方法、流程和步骤(第二轮),最后才按此执行。请随相应工具调用提交 deepThink={ problemAnalysis[](第一轮任务深研), approach[](第二轮方法流程步骤), approachBasis[](第二轮基于第一轮全部结果的依据对应) }(主 Agent 经 dsh_workplan_dispatch,专家经 self_effort)。',
441
+ deepThink: null,
442
+ }
443
+ }
444
+ const errors: string[] = []
445
+ const problemAnalysis = readTextList(value.problemAnalysis, 'deepThink.problemAnalysis', errors, { required: true, minItems: 1 })
446
+ const approach = readTextList(value.approach, 'deepThink.approach', errors, { required: true, minItems: 1 })
447
+ const approachBasis = readTextList(value.approachBasis, 'deepThink.approachBasis', errors, { required: true, minItems: 1 })
448
+ if (problemAnalysis.length > 0 && totalChars(problemAnalysis) < MIN_PLANNING_PROBLEM_CHARS) {
449
+ errors.push(`deepThink.problemAnalysis 太薄(合计 ${totalChars(problemAnalysis)} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS} 字):第一轮要全面、全盘、深入梳理、研究、思考自己的任务,写清目标与验收、现状、约束、未知、主要矛盾与边界`)
450
+ }
451
+ if (approach.length > 0 && totalChars(approach) < MIN_PLANNING_APPROACH_CHARS) {
452
+ errors.push(`deepThink.approach 太薄(合计 ${totalChars(approach)} 字,至少 ${MIN_PLANNING_APPROACH_CHARS} 字):第二轮要基于第一轮全部结果理清具体一步步以最高效率、少走弯路、完美完成任务的方法、流程和步骤,而不是一句目标`)
453
+ }
454
+ if (approachBasis.length > 0 && totalChars(approachBasis) < MIN_PLANNING_BASIS_CHARS) {
455
+ errors.push(`deepThink.approachBasis 太薄(合计 ${totalChars(approachBasis)} 字,至少 ${MIN_PLANNING_BASIS_CHARS} 字):要写清第二轮的方法、流程、步骤如何基于第一轮完成好的所有结果`)
456
+ }
457
+ if (errors.length > 0) {
458
+ return { ok: false, code: 'MAIN_DEEP_THINK_INCOMPLETE', error: errors.join(';'), deepThink: null }
459
+ }
460
+ return { ok: true, deepThink: { problemAnalysis, approach, approachBasis } }
461
+ }
462
+
463
+ /**
464
+ * 回放侧消毒(G1 教训:写入与消费双侧同一判据):durable 日志里的主 Agent
465
+ * 两轮产物重新过一遍校验,非法/被篡改 ⇒ null(门禁要求重新提交),合法 ⇒
466
+ * 归一化后的产物。旧日志无该字段 ⇒ undefined 进、null 出,零迁移不报错。
467
+ */
468
+ export function sanitizeMainDeepThink(value: any): MainDeepThink | null {
469
+ const check = validateMainDeepThink(value)
470
+ return check.ok ? check.deepThink : null
471
+ }
@@ -1122,9 +1122,15 @@ export function buildTaskAnchor(taskText: unknown, sourceMessageIds: unknown = [
1122
1122
  const ids = Array.isArray(sourceMessageIds)
1123
1123
  ? sourceMessageIds.filter((id): id is string => typeof id === 'string').slice(0, 30)
1124
1124
  : []
1125
+ /*
1126
+ * [3.0.0] 哈希必须对截断后的 text 计算:plan.ts#readTaskAnchor 重算口径是
1127
+ * `sha256(已落档 text)`(落档 text 已截断到 MAX_TASK_ANCHOR_CHARS)。旧实现
1128
+ * 对完整 text 取哈希,长锚点写入后读档校验必失败(锚点被静默丢弃)。
1129
+ */
1130
+ const storedText = text.slice(0, MAX_TASK_ANCHOR_CHARS)
1125
1131
  return {
1126
- text: text.slice(0, MAX_TASK_ANCHOR_CHARS),
1127
- sha256: createHash('sha256').update(text, 'utf8').digest('hex'),
1132
+ text: storedText,
1133
+ sha256: createHash('sha256').update(storedText, 'utf8').digest('hex'),
1128
1134
  length: text.length,
1129
1135
  sourceMessageIds: ids,
1130
1136
  }
@@ -1259,7 +1265,18 @@ export function auditTaskUnderstanding(plan: any, context: PlanAuditContext = {}
1259
1265
  const listedOption = new RegExp(
1260
1266
  '(?:^|[^A-Za-z])' + reference.token + '\\s*(?:方案|选项|=|=|:|:|、|\\)|)|\\.|.)\\s*\\S',
1261
1267
  )
1262
- if (/^[A-D]$/.test(reference.token) && !listedOption.test(conversation)) return reference
1268
+ /*
1269
+ * [2.5.5][治本] 反序枚举同样算「列出选项」:助手常用「方案 A(推荐)」/
1270
+ * 「选项 A」写法(标记在字母前),旧正则只认「A 方案/A:…」正序,导致
1271
+ * 用户回「选A」时被 CONTEXT_GUARD 误判无先行词、烧掉一次规划尝试
1272
+ * (本会话 turn 2 第 2 次尝试现场)。两种语序任一命中即视为已列出。
1273
+ */
1274
+ const listedOptionReverse = new RegExp(
1275
+ '(?:方案|选项)\\s*' + reference.token + '(?:[^A-Za-z]|$)',
1276
+ )
1277
+ if (/^[A-D]$/.test(reference.token)
1278
+ && !listedOption.test(conversation)
1279
+ && !listedOptionReverse.test(conversation)) return reference
1263
1280
  /*
1264
1281
  * [T3] Record where the referent came from. Reusing 'context' for an
1265
1282
  * antecedent found inside the task text would misreport an empty