dsh-workplan 2.3.2 → 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.
- package/CHANGELOG.md +123 -0
- package/README.en.md +2 -2
- package/README.md +2 -2
- package/README.zh.md +2 -2
- package/client.js +103 -3
- package/docs/cc/ADV-FSP-FUNCTIONAL-SPEC.md +3 -2
- package/docs/cc/AVA-VULNERABILITY-ANALYSIS.md +12 -2
- package/docs/cc/SECURITY-TARGET.md +1 -0
- package/docs/release-record-2.3.2-20261110.md +25 -0
- package/lib/client.js +103 -3
- package/lib/comm-format.js +58 -6
- package/lib/criterion.js +215 -0
- package/lib/dept-journal.js +319 -0
- package/lib/host.js +279 -15
- package/lib/llm-rules.js +478 -0
- package/lib/plan.js +1537 -136
- package/lib/replan.js +66 -44
- package/lib/runtime.js +3458 -628
- package/lib/three-phase.js +106 -20
- package/lib/understanding.js +18 -3
- package/lib/v3-contract.js +431 -0
- package/lib/watchdog.js +6 -1
- package/package.json +2 -2
- package/src/client.ts +110 -3
- package/src/comm-format.ts +63 -5
- package/src/criterion.ts +262 -0
- package/src/dept-journal.ts +373 -0
- package/src/host.ts +288 -16
- package/src/llm-rules.ts +667 -0
- package/src/plan.ts +1560 -130
- package/src/replan.ts +64 -42
- package/src/runtime.ts +2958 -200
- package/src/three-phase.ts +147 -20
- package/src/understanding.ts +20 -3
- package/src/v3-contract.ts +470 -0
- package/src/watchdog.ts +6 -1
package/src/three-phase.ts
CHANGED
|
@@ -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
|
-
|
|
47
|
+
/** [2.5.1] 契约版本 2:规划阶段升级为两轮深度思考协议(新增必填 approachBasis)。 */
|
|
48
|
+
export const THREE_PHASE_VERSION = 2
|
|
29
49
|
|
|
30
50
|
/**
|
|
31
|
-
*
|
|
32
|
-
*
|
|
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
|
-
*
|
|
125
|
-
*
|
|
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
|
-
|
|
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
|
-
`阶段一
|
|
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
|
-
'
|
|
326
|
-
'
|
|
327
|
-
'
|
|
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
|
-
' -
|
|
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
|
+
}
|
package/src/understanding.ts
CHANGED
|
@@ -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:
|
|
1127
|
-
sha256: createHash('sha256').update(
|
|
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
|
-
|
|
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
|