dsh-workplan 2.3.9 → 3.0.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/CHANGELOG.md +161 -0
- package/README.en.md +20 -18
- package/README.md +33 -19
- package/README.zh.md +15 -19
- package/client.js +88 -59
- package/docs/cc/ADV-FSP-FUNCTIONAL-SPEC.md +19 -6
- package/docs/cc/ADV-TDS-TOE-DESIGN.md +3 -3
- package/docs/cc/AGD-OPS-SECURE-OPERATION.md +3 -7
- package/docs/cc/AVA-VULNERABILITY-ANALYSIS.md +22 -3
- package/docs/cc/SECURITY-TARGET.md +6 -6
- package/docs/collaboration.md +17 -16
- package/lib/approval-gate.js +144 -0
- package/lib/client.js +88 -59
- package/lib/comm-format.js +58 -6
- package/lib/criterion.js +210 -0
- package/lib/dept-journal.js +319 -0
- package/lib/host.js +333 -63
- package/lib/llm-rules.js +281 -24
- package/lib/plan.js +1468 -219
- package/lib/replan.js +50 -39
- package/lib/runtime.js +3474 -1088
- package/lib/three-phase.js +106 -20
- package/lib/understanding.js +18 -3
- package/lib/v3-contract.js +431 -0
- package/lib/watchdog.js +9 -1
- package/package.json +4 -3
- package/src/approval-gate.ts +168 -0
- package/src/client.ts +88 -59
- package/src/comm-format.ts +63 -5
- package/src/criterion.ts +261 -0
- package/src/dept-journal.ts +373 -0
- package/src/host.ts +341 -64
- package/src/llm-rules.ts +349 -27
- package/src/plan.ts +1464 -210
- package/src/replan.ts +48 -37
- package/src/runtime.ts +3028 -699
- package/src/three-phase.ts +147 -20
- package/src/understanding.ts +20 -3
- package/src/v3-contract.ts +470 -0
- package/src/watchdog.ts +13 -1
package/lib/three-phase.js
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
|
* 过程约束,不是对所有后续会话的产品规则;插件不全局禁用。
|
|
@@ -21,15 +37,21 @@
|
|
|
21
37
|
* 回放日志都能看到每个部门到底梳理了什么、按什么思路做、验证了什么。
|
|
22
38
|
*/
|
|
23
39
|
import { validateRetrospective } from './lessons.js';
|
|
40
|
+
// [3.0.0] Dice 单一真源在 v3-contract(零依赖,无循环):
|
|
41
|
+
// plan.ts#criterionSimilarity 与这里的 missingCriteria 都用它。
|
|
42
|
+
import { diceSimilarity } from './v3-contract.js';
|
|
24
43
|
/** 三阶段顺序不可颠倒;这里也是结果块里 `phases` 的键名。 */
|
|
25
44
|
export const THREE_PHASE_IDS = Object.freeze(['planning', 'execution', 'verification']);
|
|
26
|
-
|
|
45
|
+
/** [2.5.1] 契约版本 2:规划阶段升级为两轮深度思考协议(新增必填 approachBasis)。 */
|
|
46
|
+
export const THREE_PHASE_VERSION = 2;
|
|
27
47
|
/**
|
|
28
|
-
*
|
|
29
|
-
*
|
|
48
|
+
* 「全面、全盘、深入」无法由代码度量,但可以给一个不可忽略的下限:
|
|
49
|
+
* 第一轮任务深研与第二轮方法、流程、步骤各至少 40 个字符,避免一个词就冒充
|
|
50
|
+
* 规划;第二轮依据(approachBasis)至少 20 个字符,避免一句空话冒充依赖对应。
|
|
30
51
|
*/
|
|
31
52
|
export const MIN_PLANNING_PROBLEM_CHARS = 40;
|
|
32
53
|
export const MIN_PLANNING_APPROACH_CHARS = 40;
|
|
54
|
+
export const MIN_PLANNING_BASIS_CHARS = 20;
|
|
33
55
|
export const MAX_PHASE_LIST_ITEMS = 20;
|
|
34
56
|
export const MAX_PHASE_ITEM_CHARS = 800;
|
|
35
57
|
export const MAX_PHASE_TOTAL_CHARS = 6000;
|
|
@@ -62,12 +84,16 @@ function totalChars(items) {
|
|
|
62
84
|
return items.reduce((sum, item) => sum + item.length, 0);
|
|
63
85
|
}
|
|
64
86
|
/**
|
|
65
|
-
* Same matching rules as `src/plan.ts#acceptanceCoverage` (Q6 / U-16
|
|
66
|
-
*
|
|
67
|
-
*
|
|
87
|
+
* Same matching rules as `src/plan.ts#acceptanceCoverage` (Q6 / U-16 +
|
|
88
|
+
* [2.0.4] 同义改写两条宽松规则,逐字对齐 plan.ts:3177-3202):
|
|
89
|
+
* stable A1…An numbering, exact full text, a longer text containing the
|
|
90
|
+
* full criterion, a near-full copy (≥85% of the criterion length), or a
|
|
91
|
+
* paraphrase with Dice ≥ 0.70 and matching negation polarity. A partial
|
|
92
|
+
* copy must not count as coverage.
|
|
68
93
|
*
|
|
69
94
|
* Kept local to avoid importing plan.ts (which imports this module); the
|
|
70
|
-
* rules are pinned by tests on both sides.
|
|
95
|
+
* rules are pinned by tests on both sides. Dice itself is shared via the
|
|
96
|
+
* zero-dependency v3-contract single source (`diceSimilarity`).
|
|
71
97
|
*/
|
|
72
98
|
function normaliseCriterion(value) {
|
|
73
99
|
return String(value ?? '')
|
|
@@ -75,6 +101,10 @@ function normaliseCriterion(value) {
|
|
|
75
101
|
.replace(/[\s,。;、,.;::!!??"'“”‘’()()\[\]【】《》<>]/g, '')
|
|
76
102
|
.replace(/^(必须|需要|应当|应该|请|务必)/, '');
|
|
77
103
|
}
|
|
104
|
+
/** 与 plan.ts#hasNegation 逐字对齐:否定/禁止语气不一致不允许判覆盖。 */
|
|
105
|
+
function hasNegation(text) {
|
|
106
|
+
return /不得|禁止|严禁|不能|不可|不允许|不应|无需|避免|排除|不超过|不低于|不高于|不等于|未通过|未完成/.test(String(text ?? ''));
|
|
107
|
+
}
|
|
78
108
|
function missingCriteria(expected, checks) {
|
|
79
109
|
const want = (Array.isArray(expected) ? expected : []).map(normaliseCriterion);
|
|
80
110
|
const got = checks.map((check) => normaliseCriterion(check.criterion)).filter(Boolean);
|
|
@@ -90,7 +120,14 @@ function missingCriteria(expected, checks) {
|
|
|
90
120
|
return true;
|
|
91
121
|
if (Math.min(row.length, criterion.length) < 6)
|
|
92
122
|
return false;
|
|
93
|
-
|
|
123
|
+
if (row.includes(criterion))
|
|
124
|
+
return true;
|
|
125
|
+
// [2.0.4] 宽松规则(与 plan.ts:3199-3201 逐字对齐):
|
|
126
|
+
if (criterion.includes(row) && row.length / criterion.length >= 0.85)
|
|
127
|
+
return true;
|
|
128
|
+
if (hasNegation(criterion) !== hasNegation(row))
|
|
129
|
+
return false;
|
|
130
|
+
return diceSimilarity(row, criterion) >= 0.7;
|
|
94
131
|
});
|
|
95
132
|
if (!covered)
|
|
96
133
|
missing.push(`A${index + 1}`);
|
|
@@ -122,10 +159,10 @@ export function validatePhaseEvidence(value, expectedAcceptance = []) {
|
|
|
122
159
|
}
|
|
123
160
|
const planningRaw = isRecord(value.planning) ? value.planning : null;
|
|
124
161
|
if (!planningRaw)
|
|
125
|
-
fail('planning', 'phases.planning
|
|
162
|
+
fail('planning', 'phases.planning 缺失(阶段一 · 两轮深度思考:先全面、全盘、深入梳理、研究、思考自己的任务,再基于其全部结果理清方法、流程、步骤)');
|
|
126
163
|
const executionRaw = isRecord(value.execution) ? value.execution : null;
|
|
127
164
|
if (!executionRaw)
|
|
128
|
-
fail('execution', 'phases.execution
|
|
165
|
+
fail('execution', 'phases.execution 缺失(阶段二:基于第二轮理清的方法、流程、步骤执行)');
|
|
129
166
|
const verificationRaw = isRecord(value.verification) ? value.verification : null;
|
|
130
167
|
if (!verificationRaw)
|
|
131
168
|
fail('verification', 'phases.verification 缺失(阶段三:逐条验证)');
|
|
@@ -140,16 +177,23 @@ export function validatePhaseEvidence(value, expectedAcceptance = []) {
|
|
|
140
177
|
required: !!planningRaw,
|
|
141
178
|
minItems: 1,
|
|
142
179
|
}),
|
|
180
|
+
approachBasis: readTextList(planningRaw?.approachBasis, 'phases.planning.approachBasis', errors, {
|
|
181
|
+
required: !!planningRaw,
|
|
182
|
+
minItems: 1,
|
|
183
|
+
}),
|
|
143
184
|
};
|
|
144
185
|
if (errors.some((item) => item.startsWith('phases.planning.problemAnalysis')))
|
|
145
186
|
failedPhase ||= 'planning';
|
|
146
187
|
if (errors.some((item) => item.startsWith('phases.planning.approach')))
|
|
147
188
|
failedPhase ||= 'planning';
|
|
148
189
|
if (planning.problemAnalysis.length > 0 && totalChars(planning.problemAnalysis) < MIN_PLANNING_PROBLEM_CHARS) {
|
|
149
|
-
fail('planning', `phases.planning.problemAnalysis 太薄(合计 ${totalChars(planning.problemAnalysis)} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS}
|
|
190
|
+
fail('planning', `phases.planning.problemAnalysis 太薄(合计 ${totalChars(planning.problemAnalysis)} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS} 字):第一轮要全面、全盘、深入梳理、研究、思考自己的任务,逐条写清目标与验收、现状、约束、未知、主要矛盾与边界`);
|
|
150
191
|
}
|
|
151
192
|
if (planning.approach.length > 0 && totalChars(planning.approach) < MIN_PLANNING_APPROACH_CHARS) {
|
|
152
|
-
fail('planning', `phases.planning.approach 太薄(合计 ${totalChars(planning.approach)} 字,至少 ${MIN_PLANNING_APPROACH_CHARS}
|
|
193
|
+
fail('planning', `phases.planning.approach 太薄(合计 ${totalChars(planning.approach)} 字,至少 ${MIN_PLANNING_APPROACH_CHARS} 字):第二轮要基于第一轮全部结果理清具体一步步执行、完美完成任务的方法、流程和步骤,而不是一句目标`);
|
|
194
|
+
}
|
|
195
|
+
if (planning.approachBasis.length > 0 && totalChars(planning.approachBasis) < MIN_PLANNING_BASIS_CHARS) {
|
|
196
|
+
fail('planning', `phases.planning.approachBasis 太薄(合计 ${totalChars(planning.approachBasis)} 字,至少 ${MIN_PLANNING_BASIS_CHARS} 字):要写清第二轮的方法、流程、步骤如何基于第一轮梳理、研究、思考完成好的所有结果`);
|
|
153
197
|
}
|
|
154
198
|
const execution = {
|
|
155
199
|
steps: readTextList(executionRaw?.steps, 'phases.execution.steps', errors, {
|
|
@@ -224,6 +268,7 @@ export function validatePhaseEvidence(value, expectedAcceptance = []) {
|
|
|
224
268
|
...planning.constraints,
|
|
225
269
|
...planning.unknowns,
|
|
226
270
|
...planning.approach,
|
|
271
|
+
...planning.approachBasis,
|
|
227
272
|
...execution.steps,
|
|
228
273
|
...execution.deviations,
|
|
229
274
|
verification.requirementCheck,
|
|
@@ -248,7 +293,7 @@ export function phaseGateFromErrors(errors) {
|
|
|
248
293
|
export function phaseSummaryLine(phases) {
|
|
249
294
|
const deviations = phases.execution.deviations.length;
|
|
250
295
|
return [
|
|
251
|
-
`阶段一
|
|
296
|
+
`阶段一 规划 · 两轮深度思考(第一轮任务深研 ${phases.planning.problemAnalysis.length} 条 / 第二轮方法流程步骤 ${phases.planning.approach.length} 步 / 第二轮依据 ${phases.planning.approachBasis.length} 条)`,
|
|
252
297
|
`阶段二 执行(${phases.execution.steps.length} 步${deviations ? ` / 偏离 ${deviations} 处` : ''})`,
|
|
253
298
|
`阶段三 验证(${phases.verification.checks.length} 项${phases.verification.allPassed ? ',全部通过' : ',未全部通过'};`
|
|
254
299
|
+ `复盘 ${phases.verification.retrospective.problems.length} 个问题 / `
|
|
@@ -265,13 +310,13 @@ export function phaseSummaryLine(phases) {
|
|
|
265
310
|
*/
|
|
266
311
|
export function threePhasePromptLines() {
|
|
267
312
|
return [
|
|
268
|
-
'
|
|
269
|
-
'【阶段一 ·
|
|
270
|
-
'
|
|
271
|
-
'
|
|
272
|
-
'
|
|
313
|
+
'三阶段工作法(用户强制要求;顺序不可颠倒,阶段一的两轮深度思考没有完成之前禁止动手执行):',
|
|
314
|
+
'【阶段一 · 规划阶段 = 两轮深度思考(部门负责人、全球顶尖专家执行自己的任务时同一口径,顺序与依赖不可颠倒)】',
|
|
315
|
+
' 第一轮 · 任务深研:先全面、全盘、深入梳理、研究、思考自己的任务——逐条写清任务目标与验收标准、现状与已知事实、约束条件、未知/待确认项、主要矛盾、工作边界与依赖,结果写入 phases.planning.problemAnalysis;',
|
|
316
|
+
' 第二轮 · 理清方法流程步骤:基于刚才第一轮完成好的所有结果,再全面、全盘、深入地开展梳理、研究和思考,理清自己的思路,理清自己该具体如何一步步以最高效率执行、确保完美完成自己任务的方法、流程和步骤——每一步做什么、产出什么、依赖什么、风险与对策、如何证明做对了,并写清全程如何少走弯路(先查历史教训记忆、先验证再动手、不重复同样的试错),结果写入 phases.planning.approach;同时把第二轮如何基于第一轮全部结果写入 phases.planning.approachBasis(逐条对应:第一轮的哪些事实/约束/矛盾决定了第二轮的哪些方法/流程/步骤);',
|
|
317
|
+
' 自检:任何一条验收标准或用户原要求没有落在第二轮的方法、流程、步骤上,就回到第一轮重做;两轮深度思考没有完成并写全(problemAnalysis + approach + approachBasis)之前,不得进入阶段二。',
|
|
273
318
|
'【阶段二 · 执行阶段】',
|
|
274
|
-
'
|
|
319
|
+
' 最后,基于刚才第二轮理清楚的所有方法、流程、步骤,开始具体的执行工作:严格按 phases.planning.approach 执行。出现新事实需要偏离时,必须记录偏离原因、证据与调整后的做法,不得静默改道。',
|
|
275
320
|
'【阶段三 · 验证阶段】',
|
|
276
321
|
' 执行完成后逐条验证验收标准与用户原要求:每条都要有可复核的证据(命令输出/文件/引用);验证未通过不得报 done,无法确认写 unverified。',
|
|
277
322
|
'【阶段三收尾 · 自我学习复盘(强制)】',
|
|
@@ -282,8 +327,49 @@ export function threePhasePromptLines() {
|
|
|
282
327
|
' 4) prevention:以后如何预防再犯,至少 1 条,必须写成「遇到…先…」的可执行硬规则。',
|
|
283
328
|
' 插件会在完成判定时复核这四项,并在通过后把复盘写入永久记忆文件;下次派发同类任务时,历史教训会自动出现在提示词里。',
|
|
284
329
|
'插件使用说明(三阶段证据门禁):',
|
|
285
|
-
' -
|
|
330
|
+
' - 阶段一、二:先把两轮深度思考产物(第一轮任务深研 problemAnalysis、第二轮方法流程步骤 approach、第二轮依据 approachBasis)与执行记录写全;此时不要调用 dsh_workplan_verify,它会因缺少前两阶段证据返回 PHASE_GATE 与待补项(这是证据门禁,不是禁用插件)。',
|
|
286
331
|
' - 阶段三:可以调用 dsh_workplan_verify 让插件做最终核验:提交 planning / execution / verification 三阶段证据,插件返回 passed 或仍需补齐的 gaps;未通过先修复再回报。遇阻时可用 dsh_workplan_escalate 上报,它是安全通道,不属于三阶段产物。',
|
|
287
332
|
' - 结果块里的 phases 是必填项:缺任一阶段、内容为空、或验证未全部通过,插件都会判为未完成,不能用 done 收尾。',
|
|
288
333
|
];
|
|
289
334
|
}
|
|
335
|
+
/**
|
|
336
|
+
* 主 Agent 两轮思考产物校验(派发硬门禁的唯一判据,与结算门禁同一口径:
|
|
337
|
+
* 第一轮 ≥40 字、第二轮方法流程步骤 ≥40 字、第二轮依据 ≥20 字)。
|
|
338
|
+
* 纯函数:dispatchTool 与测试同口径消费,门禁不能被提示词绕过。
|
|
339
|
+
*/
|
|
340
|
+
export function validateMainDeepThink(value) {
|
|
341
|
+
if (!isRecord(value)) {
|
|
342
|
+
return {
|
|
343
|
+
ok: false,
|
|
344
|
+
code: 'MAIN_DEEP_THINK_MISSING',
|
|
345
|
+
error: '两轮深度思考产物缺失:执行自己的任务必须先全面、全盘、深入梳理、研究、思考自己的任务(第一轮),再基于第一轮完成好的所有结果再全面、全盘、深入地开展梳理、研究和思考,理清具体如何一步步以最高效率、少走弯路、完美完成任务的方法、流程和步骤(第二轮),最后才按此执行。请随相应工具调用提交 deepThink={ problemAnalysis[](第一轮任务深研), approach[](第二轮方法流程步骤), approachBasis[](第二轮基于第一轮全部结果的依据对应) }(主 Agent 经 dsh_workplan_dispatch,专家经 self_effort)。',
|
|
346
|
+
deepThink: null,
|
|
347
|
+
};
|
|
348
|
+
}
|
|
349
|
+
const errors = [];
|
|
350
|
+
const problemAnalysis = readTextList(value.problemAnalysis, 'deepThink.problemAnalysis', errors, { required: true, minItems: 1 });
|
|
351
|
+
const approach = readTextList(value.approach, 'deepThink.approach', errors, { required: true, minItems: 1 });
|
|
352
|
+
const approachBasis = readTextList(value.approachBasis, 'deepThink.approachBasis', errors, { required: true, minItems: 1 });
|
|
353
|
+
if (problemAnalysis.length > 0 && totalChars(problemAnalysis) < MIN_PLANNING_PROBLEM_CHARS) {
|
|
354
|
+
errors.push(`deepThink.problemAnalysis 太薄(合计 ${totalChars(problemAnalysis)} 字,至少 ${MIN_PLANNING_PROBLEM_CHARS} 字):第一轮要全面、全盘、深入梳理、研究、思考自己的任务,写清目标与验收、现状、约束、未知、主要矛盾与边界`);
|
|
355
|
+
}
|
|
356
|
+
if (approach.length > 0 && totalChars(approach) < MIN_PLANNING_APPROACH_CHARS) {
|
|
357
|
+
errors.push(`deepThink.approach 太薄(合计 ${totalChars(approach)} 字,至少 ${MIN_PLANNING_APPROACH_CHARS} 字):第二轮要基于第一轮全部结果理清具体一步步以最高效率、少走弯路、完美完成任务的方法、流程和步骤,而不是一句目标`);
|
|
358
|
+
}
|
|
359
|
+
if (approachBasis.length > 0 && totalChars(approachBasis) < MIN_PLANNING_BASIS_CHARS) {
|
|
360
|
+
errors.push(`deepThink.approachBasis 太薄(合计 ${totalChars(approachBasis)} 字,至少 ${MIN_PLANNING_BASIS_CHARS} 字):要写清第二轮的方法、流程、步骤如何基于第一轮完成好的所有结果`);
|
|
361
|
+
}
|
|
362
|
+
if (errors.length > 0) {
|
|
363
|
+
return { ok: false, code: 'MAIN_DEEP_THINK_INCOMPLETE', error: errors.join(';'), deepThink: null };
|
|
364
|
+
}
|
|
365
|
+
return { ok: true, deepThink: { problemAnalysis, approach, approachBasis } };
|
|
366
|
+
}
|
|
367
|
+
/**
|
|
368
|
+
* 回放侧消毒(G1 教训:写入与消费双侧同一判据):durable 日志里的主 Agent
|
|
369
|
+
* 两轮产物重新过一遍校验,非法/被篡改 ⇒ null(门禁要求重新提交),合法 ⇒
|
|
370
|
+
* 归一化后的产物。旧日志无该字段 ⇒ undefined 进、null 出,零迁移不报错。
|
|
371
|
+
*/
|
|
372
|
+
export function sanitizeMainDeepThink(value) {
|
|
373
|
+
const check = validateMainDeepThink(value);
|
|
374
|
+
return check.ok ? check.deepThink : null;
|
|
375
|
+
}
|
package/lib/understanding.js
CHANGED
|
@@ -956,9 +956,15 @@ export function buildTaskAnchor(taskText, sourceMessageIds = []) {
|
|
|
956
956
|
const ids = Array.isArray(sourceMessageIds)
|
|
957
957
|
? sourceMessageIds.filter((id) => typeof id === 'string').slice(0, 30)
|
|
958
958
|
: [];
|
|
959
|
+
/*
|
|
960
|
+
* [3.0.0] 哈希必须对截断后的 text 计算:plan.ts#readTaskAnchor 重算口径是
|
|
961
|
+
* `sha256(已落档 text)`(落档 text 已截断到 MAX_TASK_ANCHOR_CHARS)。旧实现
|
|
962
|
+
* 对完整 text 取哈希,长锚点写入后读档校验必失败(锚点被静默丢弃)。
|
|
963
|
+
*/
|
|
964
|
+
const storedText = text.slice(0, MAX_TASK_ANCHOR_CHARS);
|
|
959
965
|
return {
|
|
960
|
-
text:
|
|
961
|
-
sha256: createHash('sha256').update(
|
|
966
|
+
text: storedText,
|
|
967
|
+
sha256: createHash('sha256').update(storedText, 'utf8').digest('hex'),
|
|
962
968
|
length: text.length,
|
|
963
969
|
sourceMessageIds: ids,
|
|
964
970
|
};
|
|
@@ -1090,7 +1096,16 @@ export function auditTaskUnderstanding(plan, context = {}) {
|
|
|
1090
1096
|
// Task-text entities never satisfy this rule on their own: the option must
|
|
1091
1097
|
// be defined where the user chose it, i.e. in the conversation.
|
|
1092
1098
|
const listedOption = new RegExp('(?:^|[^A-Za-z])' + reference.token + '\\s*(?:方案|选项|=|=|:|:|、|\\)|)|\\.|.)\\s*\\S');
|
|
1093
|
-
|
|
1099
|
+
/*
|
|
1100
|
+
* [2.5.5][治本] 反序枚举同样算「列出选项」:助手常用「方案 A(推荐)」/
|
|
1101
|
+
* 「选项 A」写法(标记在字母前),旧正则只认「A 方案/A:…」正序,导致
|
|
1102
|
+
* 用户回「选A」时被 CONTEXT_GUARD 误判无先行词、烧掉一次规划尝试
|
|
1103
|
+
* (本会话 turn 2 第 2 次尝试现场)。两种语序任一命中即视为已列出。
|
|
1104
|
+
*/
|
|
1105
|
+
const listedOptionReverse = new RegExp('(?:方案|选项)\\s*' + reference.token + '(?:[^A-Za-z]|$)');
|
|
1106
|
+
if (/^[A-D]$/.test(reference.token)
|
|
1107
|
+
&& !listedOption.test(conversation)
|
|
1108
|
+
&& !listedOptionReverse.test(conversation))
|
|
1094
1109
|
return reference;
|
|
1095
1110
|
/*
|
|
1096
1111
|
* [T3] Record where the referent came from. Reusing 'context' for an
|