dsh-workplan 2.3.0 → 2.3.9

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/plan.js CHANGED
@@ -179,6 +179,49 @@ export const LIKELIHOODS = Object.freeze(['low', 'medium', 'high']);
179
179
  */
180
180
  export const REASONING_EFFORTS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
181
181
  export const DEFAULT_REASONING_EFFORT = 'high';
182
+ export const QWEN_MODEL_EFFORTS = Object.freeze(['low', 'medium', 'xhigh']);
183
+ export const OTHER_MODEL_EFFORTS = Object.freeze(['low', 'high', 'max']);
184
+ /** 判定模型家族:qwen 开头(trim+小写)→ 'qwen';其余非空 → 'other';空/缺失 → null(不约束)。 */
185
+ export function classifyModelFamily(modelId) {
186
+ const normalized = String(modelId ?? '').trim().toLowerCase();
187
+ if (!normalized)
188
+ return null;
189
+ return normalized.startsWith('qwen') ? 'qwen' : 'other';
190
+ }
191
+ /** 家族 → 允许等级集合(用户要求 1/2 硬白名单);未知家族 → null = 不施加约束。 */
192
+ export function effortsForModelFamily(family) {
193
+ if (family === 'qwen')
194
+ return QWEN_MODEL_EFFORTS;
195
+ if (family === 'other')
196
+ return OTHER_MODEL_EFFORTS;
197
+ return null;
198
+ }
199
+ /** 一步式:按模型 id 得到等级集合;模型名缺失返回 null(不约束)。 */
200
+ export function allowedEffortsForModel(modelId) {
201
+ return effortsForModelFamily(classifyModelFamily(modelId));
202
+ }
203
+ export const COMPLEXITY_EFFORT_BY_FAMILY = Object.freeze({
204
+ qwen: Object.freeze({ light: 'low', moderate: 'medium', heavy: 'xhigh' }),
205
+ other: Object.freeze({ light: 'low', moderate: 'high', heavy: 'max' }),
206
+ });
207
+ /** 按家族+复杂度取应使用档位;家族未知返回 null。 */
208
+ export function effortForComplexity(family, complexity) {
209
+ if (!family)
210
+ return null;
211
+ return COMPLEXITY_EFFORT_BY_FAMILY[family][complexity];
212
+ }
213
+ /** 集合内最高档(强度序与 runtime EFFORT_STRENGTH_ORDER 同源);空集合返回 null。 */
214
+ export function highestEffortOf(levels) {
215
+ if (!levels || levels.length === 0)
216
+ return null;
217
+ const order = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
218
+ let best = null;
219
+ for (const id of levels) {
220
+ if (best === null || order.indexOf(id) > order.indexOf(best))
221
+ best = id;
222
+ }
223
+ return best;
224
+ }
182
225
  export const DEPARTMENTS = Object.freeze({
183
226
  engineering: { zh: '工程研发', en: 'Engineering' },
184
227
  research: { zh: '研究分析', en: 'Research' },
@@ -215,10 +258,46 @@ export function truncate(value, max) {
215
258
  export function messageText(message) {
216
259
  if (!message || !Array.isArray(message.content))
217
260
  return '';
218
- return message.content
261
+ const texts = message.content
219
262
  .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
220
- .map((block) => block.text)
221
- .join('\n');
263
+ .map((block) => block.text);
264
+ /*
265
+ * [2.3.1][D1] 附件事实渲染(用户 2026-11-10 点名的严重缺陷:规划器与 fresh
266
+ * 子 Agent 看不见用户图片)。
267
+ *
268
+ * 旧实现只收 text 块:image/file 块的 attachment 元数据(attachmentId/名称/
269
+ * 尺寸)在到达规划器 taskText 之前就被整块丢弃,专家被迫 escalate 请示
270
+ * 「截图在哪」,往返吃掉整段时间预算(wp-73bb2cd4 事故实证:修复主链 8 分钟、
271
+ * 往返 17 分钟)。
272
+ *
273
+ * 现在把附件渲染成一行标注并入文本面,taskText→taskAnchor→派发锚点块→回放
274
+ * 上下文全部同源受益;标注含 attachment-id(官方读图工具接受该 id 作为
275
+ * path),接收方可直接读取,不再靠猜。
276
+ * 消费方安全审计(2026-11-10):plan/result/cancel/update 四类 marker 解析
277
+ * 消息永不含图片块;replan/supersede 为用户消息子串匹配,附加行零误伤。
278
+ */
279
+ const notes = message.content
280
+ .filter((block) => block && (block.type === 'image' || block.type === 'file' || block.type === 'document') && (block.attachment ?? block.file))
281
+ .map((block) => renderAttachmentNote(block))
282
+ .filter((line) => line !== '');
283
+ if (notes.length === 0)
284
+ return texts.join('\n');
285
+ return [...texts, ...notes].join('\n');
286
+ }
287
+ /** [2.3.1][D1] 单个附件块的只读标注行;元数据缺失时返回空串(不泄漏、不猜测)。 */
288
+ function renderAttachmentNote(block) {
289
+ const att = block.attachment ?? block.file ?? {};
290
+ const id = typeof att.attachmentId === 'string' ? att.attachmentId : '';
291
+ const name = typeof att.name === 'string' ? att.name : (typeof att.filename === 'string' ? att.filename : '');
292
+ if (!id && !name)
293
+ return '';
294
+ const media = typeof att.mediaType === 'string' ? att.mediaType : '';
295
+ const size = Number.isFinite(Number(att.width)) && Number.isFinite(Number(att.height))
296
+ ? `|${String(att.width)}x${String(att.height)}` : '';
297
+ return `[用户附件] ${block.type === 'image' ? '图片' : '文件'} "${name || '未命名'}"`
298
+ + (media ? `|mediaType=${media}` : '') + size
299
+ + (id ? `|attachment-id: ${id}` : '')
300
+ + '|如需其内容:把 attachment-id 作为 path 传给可用的读图/视觉工具直接读取,禁止凭空猜测附件内容。';
222
301
  }
223
302
  /*
224
303
  * [1.8.12] 不能让正文里的「包名:行号」变成跨会话引用。
@@ -916,10 +995,13 @@ function checkPlanGraph(plan, errors) {
916
995
  /**
917
996
  * Validate an untrusted planner object. Never throws for malformed input.
918
997
  *
919
- * @param {unknown} raw
920
- * @returns {{ok: true, plan: object} | {ok: false, errors: string[]}}
998
+ * [2.3.9][T3] options.allowedEfforts:当前模型家族的等级集合(真源
999
+ * allowedEffortsForModel)。传入时,规划器**显式写出**的集合外档位直接拒绝并
1000
+ * 点名(事前约束,要求 1/2;缺失/回落的 high 不在此列——派发侧静态收窄会带
1001
+ * qwen-rule 留痕降级,向后兼容旧回放零迁移)。null/未传 ⇒ 不施加(回放、旧
1002
+ * 调用零行为变化)。REASONING_EFFORTS 五档仍是存储全集,不得删档。
921
1003
  */
922
- export function validatePlan(raw) {
1004
+ export function validatePlan(raw, options) {
923
1005
  if (!isRecord(raw)) {
924
1006
  return { ok: false, errors: ['计划必须是 JSON 对象'] };
925
1007
  }
@@ -937,6 +1019,32 @@ export function validatePlan(raw) {
937
1019
  verification: readVerification(raw.verification, errors),
938
1020
  practiceLoop: readPracticeLoop(raw.practiceLoop, errors),
939
1021
  };
1022
+ const allowedEfforts = options && options.allowedEfforts ? options.allowedEfforts : null;
1023
+ if (allowedEfforts !== null && Array.isArray(raw.stages)) {
1024
+ /*
1025
+ * [2.3.9][T3/llm-rules] 模型感知的校验收窄(用户要求 1/2,主 Agent 口径):
1026
+ * 五档仍是存储全集(不得删档),但调用方传入当前模型家族等级集合时,
1027
+ * 规划器**显式写出**的集合外档位拒绝并点名字段——错误经重试回路回喂
1028
+ * 规划器自纠,属于事前约束而非派发后静默钳制。缺失档位不在此拦(由
1029
+ * readSubtasks 回落 high、派发侧静态收窄带 qwen-rule 留痕降级);未传
1030
+ * options 的调用(回放/旧路径)零行为变化。
1031
+ */
1032
+ for (let stageIndex = 0; stageIndex < raw.stages.length; stageIndex += 1) {
1033
+ const stage = raw.stages[stageIndex];
1034
+ if (!isRecord(stage) || !Array.isArray(stage.subtasks))
1035
+ continue;
1036
+ for (let subtaskIndex = 0; subtaskIndex < stage.subtasks.length; subtaskIndex += 1) {
1037
+ const subtask = stage.subtasks[subtaskIndex];
1038
+ if (!isRecord(subtask))
1039
+ continue;
1040
+ const effort = subtask.reasoningEffort;
1041
+ if (effort !== undefined && effort !== null
1042
+ && !(typeof effort === 'string' && allowedEfforts.includes(effort))) {
1043
+ push(errors, `stages[${stageIndex}].subtasks[${subtaskIndex}].reasoningEffort`, `"${String(effort)}" 不在当前模型家族的推理等级集合 {${allowedEfforts.join(' / ')}} 内(qwen 系仅 low / medium / xhigh;非 qwen 系仅 low / high / max),必须改用集合内档位或删除该字段`);
1044
+ }
1045
+ }
1046
+ }
1047
+ }
940
1048
  checkPlanGraph(plan, errors);
941
1049
  if (errors.length > 0)
942
1050
  return { ok: false, errors };
@@ -967,12 +1075,37 @@ export function flattenSubtasks(plan) {
967
1075
  * 规划器返回的 JSON 常见三类损伤:少一个 `}`、多一个尾逗号、字符串里有裸换行。
968
1076
  * 旧实现直接 JSON.parse,一个字符之差就抛 INVALID_JSON,整个计划降级。
969
1077
  * 这里做的是纯结构修复:配对括号、去掉尾逗号、把字符串里的裸控制符转义。
1078
+ *
1079
+ * [2.3.2][D2-P0] D2 现场(qwen3.8-flash INVALID_JSON ×3、86.9 秒白烧)实测穿透的
1080
+ * 三类损伤——成员间漏逗号、字符串外全角标点、多余闭合括号——在同一趟扫描内补齐。
1081
+ * 旧实现只「补」不「插/删/归一」,这三类必然失败后靠全量重掷碰运气。三条新规则
1082
+ * 全部满足「只修结构、绝不碰内容」红线:
1083
+ * 1. 插逗号:容器内(栈非空)值结束符(`"`/`}`/`]`/数字/true|false|null)之后
1084
+ * 紧邻下一个起点 token 且无分隔符 → 插入 `,`;深度 0 不插(不吞多对象文档);
1085
+ * 2. 归一半角:仅字符串外 `,`→`,`、`:`→`:`、`“`/`”`→`"`;字符串内一字不动;
1086
+ * 3. 删多余闭合:栈已空时出现的 `}`/`]` 直接丢弃(旧实现原样保留 → 必解析失败)。
970
1087
  * 绝不猜测、绝不编造任何字段或值——修不好就照旧抛错。
971
1088
  */
972
1089
  export function repairJsonStructure(input) {
973
1090
  const stack = [];
974
1091
  let inString = false;
975
1092
  let escaped = false;
1093
+ // [2.3.2] afterValue = 上一个字符串外记号是「完整值收尾」(闭合引号/闭合括号/裸 token 结束)。
1094
+ let afterValue = false;
1095
+ // [2.3.2] inToken = 正在读数字或 true/false/null 这类裸 token(须等它结束才可能插逗号)。
1096
+ let inToken = false;
1097
+ // [2.3.2] 字符串定界样式:全角引号开的字符串须由 `”`(或半角 `"`)闭合,
1098
+ // 否则 `{“a”:1}` 的 `”` 会被当作字符串内容吞掉;半角字符串不受影响。
1099
+ let stringUnicode = false;
1100
+ const isTokenChar = (ch) => (ch >= '0' && ch <= '9')
1101
+ || (ch >= 'a' && ch <= 'z')
1102
+ || (ch >= 'A' && ch <= 'Z')
1103
+ || ch === '.' || ch === '+' || ch === '-';
1104
+ const separatorBefore = () => {
1105
+ // 只在「值收尾 → 新值起点」且确有容器时才插逗号;键后接冒号、值后接闭合都不走这里。
1106
+ if (afterValue && stack.length > 0)
1107
+ out += ',';
1108
+ };
976
1109
  let out = '';
977
1110
  for (let i = 0; i < input.length; i += 1) {
978
1111
  const ch = input[i];
@@ -987,9 +1120,10 @@ export function repairJsonStructure(input) {
987
1120
  escaped = true;
988
1121
  continue;
989
1122
  }
990
- if (ch === '"') {
1123
+ if (ch === '"' || (stringUnicode && ch === '”')) {
991
1124
  inString = false;
992
- out += ch;
1125
+ afterValue = true;
1126
+ out += '"';
993
1127
  continue;
994
1128
  }
995
1129
  if (ch === '\n') {
@@ -1011,17 +1145,40 @@ export function repairJsonStructure(input) {
1011
1145
  out += ch;
1012
1146
  continue;
1013
1147
  }
1148
+ if (inToken && !isTokenChar(ch)) {
1149
+ inToken = false;
1150
+ afterValue = true;
1151
+ }
1014
1152
  if (ch === '"') {
1153
+ separatorBefore();
1015
1154
  inString = true;
1155
+ stringUnicode = false;
1156
+ afterValue = false;
1016
1157
  out += ch;
1017
1158
  continue;
1018
1159
  }
1160
+ // [2.3.2] 全角引号 → 半角双引号开字符串(仅字符串外;归一只动标点不动内容)。
1161
+ if (ch === '“' || ch === '”' || ch === '"') {
1162
+ separatorBefore();
1163
+ inString = true;
1164
+ stringUnicode = true;
1165
+ afterValue = false;
1166
+ out += '"';
1167
+ continue;
1168
+ }
1019
1169
  if (ch === '{' || ch === '[') {
1170
+ separatorBefore();
1020
1171
  stack.push(ch);
1172
+ afterValue = false;
1021
1173
  out += ch;
1022
1174
  continue;
1023
1175
  }
1024
1176
  if (ch === '}' || ch === ']') {
1177
+ // [2.3.2] 规则 3:栈空 = 这个闭合符在语法上无处安放,丢弃(旧实现保留 → E 类穿透)。
1178
+ if (stack.length === 0) {
1179
+ afterValue = true;
1180
+ continue;
1181
+ }
1025
1182
  const want = ch === '}' ? '{' : '[';
1026
1183
  while (stack.length > 0 && stack[stack.length - 1] !== want) {
1027
1184
  out += stack.pop() === '{' ? '}' : ']';
@@ -1029,6 +1186,26 @@ export function repairJsonStructure(input) {
1029
1186
  if (stack.length > 0)
1030
1187
  stack.pop();
1031
1188
  out += ch;
1189
+ afterValue = true;
1190
+ continue;
1191
+ }
1192
+ if (ch === ',' || ch === ',') {
1193
+ // [2.3.2] 规则 2:字符串外全角逗号归一为半角。
1194
+ out += ',';
1195
+ afterValue = false;
1196
+ continue;
1197
+ }
1198
+ if (ch === ':' || ch === ':') {
1199
+ // [2.3.2] 规则 2:字符串外全角冒号归一为半角;键后的冒号不是「新值起点」,不插逗号。
1200
+ out += ':';
1201
+ afterValue = false;
1202
+ continue;
1203
+ }
1204
+ if (isTokenChar(ch)) {
1205
+ separatorBefore();
1206
+ inToken = true;
1207
+ afterValue = false;
1208
+ out += ch;
1032
1209
  continue;
1033
1210
  }
1034
1211
  out += ch;
@@ -1040,7 +1217,46 @@ export function repairJsonStructure(input) {
1040
1217
  return stripTrailingCommas(out);
1041
1218
  }
1042
1219
  function stripTrailingCommas(input) {
1043
- return input.replace(/,(\s*[}\]])/g, '$1');
1220
+ /*
1221
+ * [2.3.2][D2-QA-1 修复] 字符串边界感知的尾逗号删除(T3 审查红线发现)。
1222
+ *
1223
+ * 旧实现正则 /,(\s*[}\]])/g 不感知字符串边界,会吃掉字符串值内部的
1224
+ * 「半角逗号+空白+闭括号」——`{"note":"p, } q"}` 被改成 `"p } q"`,是值
1225
+ * 篡改(缺陷自 2.1.0 既有,本补丁 P0 扩能后其可达面被扩大;T3 探针
1226
+ * TAMPER-3 实锤并定性为既有)。现在只有字符串外的逗号才会被删,
1227
+ * 与旧语义一致(只删逗号、保留其间空白与闭括号)。
1228
+ */
1229
+ let inString = false;
1230
+ let escaped = false;
1231
+ let out = '';
1232
+ for (let i = 0; i < input.length; i += 1) {
1233
+ const ch = input[i];
1234
+ if (inString) {
1235
+ out += ch;
1236
+ if (escaped)
1237
+ escaped = false;
1238
+ else if (ch === '\\')
1239
+ escaped = true;
1240
+ else if (ch === '"')
1241
+ inString = false;
1242
+ continue;
1243
+ }
1244
+ if (ch === '"') {
1245
+ inString = true;
1246
+ out += ch;
1247
+ continue;
1248
+ }
1249
+ if (ch === ',') {
1250
+ let j = i + 1;
1251
+ while (j < input.length && input[j].trim() === '')
1252
+ j += 1;
1253
+ const next = input[j];
1254
+ if (next === '}' || next === ']')
1255
+ continue;
1256
+ }
1257
+ out += ch;
1258
+ }
1259
+ return out;
1044
1260
  }
1045
1261
  /** 找到最后一个「成员边界」逗号(在任何嵌套深度上、且不在字符串内)。 */
1046
1262
  function lastMemberComma(input) {
@@ -1079,6 +1295,25 @@ function* truncatedCandidates(input, rounds = 24) {
1079
1295
  yield repairJsonStructure(working);
1080
1296
  }
1081
1297
  }
1298
+ /**
1299
+ * [2.3.2][D2-P1] 定向位置反馈:旧实现回喂只有「末尾 120 字符」,断点在 6KB 文档
1300
+ * 中部时模型依然盲,只能整段重掷(×3 ≈86.9 秒白烧的机制根因之一)。V8 对长输入的
1301
+ * 解析错误带 `at position N`,这里据此从候选文本切出断点 ±60 字符原文随错误一并
1302
+ * 回喂(runtime 的 lastErrors 直接透传该 message),让下一次请求是「定向修复」而
1303
+ * 非「盲目重生成」。短输入的新式消息本身已带上下文,正则不中则原样返回。
1304
+ */
1305
+ function parseFailureHint(candidate, error) {
1306
+ const message = error instanceof Error ? error.message : String(error);
1307
+ const match = /at position (\d+)/.exec(message);
1308
+ if (!match)
1309
+ return '';
1310
+ const position = Math.min(Number(match[1]), candidate.length);
1311
+ const from = Math.max(0, position - 60);
1312
+ const to = Math.min(candidate.length, position + 60);
1313
+ const snippet = candidate.slice(from, to).replace(/\s+/g, ' ');
1314
+ return `;错误位置 ${position},断点附近原文(字符 ${from}-${to}):${JSON.stringify(snippet)}`
1315
+ + '——请只修复该处 JSON 语法后重新输出完整对象,不得改动任何字段值';
1316
+ }
1082
1317
  export function extractJson(text) {
1083
1318
  if (typeof text !== 'string' || text.trim() === '') {
1084
1319
  throw new PlanError('规划器没有返回内容', 'EMPTY_OUTPUT');
@@ -1101,7 +1336,7 @@ export function extractJson(text) {
1101
1336
  const repaired = repairJsonStructure(candidate);
1102
1337
  try {
1103
1338
  const value2 = JSON.parse(repaired);
1104
- console.warn('[dsh-workplan] 规划器 JSON 结构已修复(只补括号/逗号,未改内容)');
1339
+ console.warn('[dsh-workplan] 规划器 JSON 结构已修复(只动括号/逗号/字符串外全角标点,未改内容)');
1105
1340
  return value2;
1106
1341
  }
1107
1342
  catch {
@@ -1116,7 +1351,8 @@ export function extractJson(text) {
1116
1351
  }
1117
1352
  }
1118
1353
  }
1119
- throw new PlanError(`规划器返回的 JSON 无法解析:${error instanceof Error ? error.message : String(error)}`, 'INVALID_JSON');
1354
+ // [2.3.2][D2-P1] 抛出前附断点原文切片:重试请求据此定向修复,不再盲掷全文。
1355
+ throw new PlanError(`规划器返回的 JSON 无法解析:${error instanceof Error ? error.message : String(error)}${parseFailureHint(candidate, error)}`, 'INVALID_JSON');
1120
1356
  }
1121
1357
  }
1122
1358
  export function departmentLabel(id, language = 'zh') {
@@ -1193,6 +1429,8 @@ export function buildPlannerPrompt(taskText, cwd, conversationContext = '', budg
1193
1429
  '- 子任务必须可独立执行、可验收;不要为了凑数拆无意义任务。',
1194
1430
  '- 子任务由子 Agent 独立执行:它们没有派发权限、不能重启服务、不能安装或升级依赖。禁止把「调用 dsh_workplan_dispatch」「重启/停止 dsh web」「安装或升级插件」这类只有主 Agent 才能执行的动作写进子任务;确实需要时,写成“给出结论或建议,由主 Agent 执行”。',
1195
1431
  '- 单个子任务无须在 10 分钟内完成——10 分钟只是拆步规模建议,不是完成期限、也不构成承诺;实际时长由执行专家开工预告协商决定,不设固定完成时间;动手重的任务要拆成多个小步,避免整条计划被一个慢子任务拖住。',
1432
+ // [2.3.2][D2-P2] 半角/逗号/括号自检硬约束:与解析层兜底(P0)互为防线,中文模型全角标点高发。
1433
+ '- JSON 只允许半角标点(, : " { } [ ]);对象与数组的相邻成员之间必须有逗号;输出前自检括号成对、每个字符串以半角"闭合。',
1196
1434
  '- 不要输出 Markdown 代码围栏、解释或前后缀;只输出一个 JSON 对象。',
1197
1435
  '',
1198
1436
  '本轮时间预算(硬事实,请据此规划规模):',
@@ -3087,6 +3325,14 @@ export function buildUpdateMessage(update) {
3087
3325
  * deriveSubtaskTimeoutMs。
3088
3326
  */
3089
3327
  ...(update.timeoutMs === undefined ? {} : { timeoutMs: update.timeoutMs }),
3328
+ /*
3329
+ * [2.3.9][T4b] 梳理门禁与第三层分工必须随 durable workplan-update 回放:
3330
+ * 刷新后门禁判据(consolidation)若只剩内存一份,重启的负责人可以不经
3331
+ * 梳理直接 dispatch,硬门禁就只是「本进程内的礼貌」。delegates 是看板
3332
+ * 第三层的数据源,同理。
3333
+ */
3334
+ ...(update.consolidation === undefined ? {} : { consolidation: update.consolidation }),
3335
+ ...(update.delegates === undefined ? {} : { delegates: update.delegates }),
3090
3336
  ...(update.revision === undefined ? {} : { revision: update.revision }),
3091
3337
  at: update.at ?? Date.now(),
3092
3338
  };
@@ -3600,6 +3846,63 @@ export function applyStatus(statuses, subtaskId, patch) {
3600
3846
  .filter((item) => isRecord(item) && typeof item.id === 'string')
3601
3847
  .map((item) => ({ id: item.id, reason: truncate(String(item.reason ?? ''), 300) }));
3602
3848
  }
3849
+ /*
3850
+ * [2.3.9][T4b] 第三层派发的留档字段(用户要求 4/5:负责人「先全面梳理、
3851
+ * 再分配」的硬门禁产物 + 顶尖专家/组员的分工与实时状态)。
3852
+ *
3853
+ * `consolidation` 是梳理门禁的唯一判据:没有它,delegateTool 的 dispatch
3854
+ * 动作必须被拒(A4)。`delegates` 是看板第三层的渲染数据源(A3),其
3855
+ * requested/corrected 对就是等级钳制的留痕(A5)。两者只写同一条状态行、
3856
+ * 走同一个 durable workplan-update 回放,刷新/重启后门禁与看板不失效。
3857
+ */
3858
+ if (patch.consolidation !== undefined) {
3859
+ if (patch.consolidation === null)
3860
+ next.consolidation = null;
3861
+ else if (isRecord(patch.consolidation)) {
3862
+ const briefStrings = (value, limit, itemMax) => (Array.isArray(value) ? value : [])
3863
+ .map((entry) => truncate(String(entry ?? '').trim(), itemMax))
3864
+ .filter(Boolean)
3865
+ .slice(0, limit);
3866
+ next.consolidation = {
3867
+ problemAnalysis: briefStrings(patch.consolidation.problemAnalysis, 12, 500),
3868
+ constraints: briefStrings(patch.consolidation.constraints, 12, 300),
3869
+ unknowns: briefStrings(patch.consolidation.unknowns, 12, 300),
3870
+ approach: briefStrings(patch.consolidation.approach, 12, 500),
3871
+ assignments: (Array.isArray(patch.consolidation.assignments) ? patch.consolidation.assignments : [])
3872
+ .slice(0, 6)
3873
+ .map((item) => ({
3874
+ member: truncate(String(item?.member ?? ''), 80),
3875
+ role: item?.role === 'expert' ? 'expert' : 'member',
3876
+ task: truncate(String(item?.task ?? ''), 800),
3877
+ reasoningEffort: REASONING_EFFORTS.includes(item?.reasoningEffort) ? item.reasoningEffort : 'low',
3878
+ ...(item?.requested && item.requested !== item.reasoningEffort
3879
+ ? { requested: String(item.requested) }
3880
+ : {}),
3881
+ })),
3882
+ submittedAt: numberOrNull(patch.consolidation.submittedAt) ?? Date.now(),
3883
+ };
3884
+ }
3885
+ else {
3886
+ throw new PlanError('consolidation 必须是对象或 null', 'INVALID_CONSOLIDATION');
3887
+ }
3888
+ }
3889
+ if (patch.delegates !== undefined) {
3890
+ next.delegates = (Array.isArray(patch.delegates) ? patch.delegates : [])
3891
+ .slice(0, 6)
3892
+ .map((item) => ({
3893
+ member: truncate(String(item?.member ?? ''), 80),
3894
+ role: item?.role === 'expert' ? 'expert' : 'member',
3895
+ task: truncate(String(item?.task ?? ''), 300),
3896
+ effort: REASONING_EFFORTS.includes(item?.effort) ? item.effort : 'low',
3897
+ ...(item?.requested && item.requested !== item.effort ? { requested: String(item.requested) } : {}),
3898
+ childId: typeof item?.childId === 'string' ? truncate(item.childId, 200) : null,
3899
+ status: ['running', 'done', 'failed', 'timeout', 'rejected'].includes(item?.status) ? item.status : 'running',
3900
+ summary: typeof item?.summary === 'string' ? truncate(item.summary, 300) : '',
3901
+ error: typeof item?.error === 'string' ? truncate(item.error, 300) : null,
3902
+ startedAt: numberOrNull(item?.startedAt),
3903
+ finishedAt: numberOrNull(item?.finishedAt),
3904
+ }));
3905
+ }
3603
3906
  /*
3604
3907
  * [1.7.0] Monotonic revision + author.
3605
3908
  *
@@ -3749,6 +4052,15 @@ export function applyStatus(statuses, subtaskId, patch) {
3749
4052
  // [1.10.6] A conflict belongs to one attempt; a reset starts a new one.
3750
4053
  if (patch.artifactConflict === undefined)
3751
4054
  next.artifactConflict = undefined;
4055
+ /*
4056
+ * [2.3.9][T4b] 第三层痕迹属于上一次尝试:重置后新负责人必须重新梳理、
4057
+ * 旧专家/组员的子会话也已随上一attempt终止——留着它们会让新行「看起来
4058
+ * 已梳理/已在派」,门禁(consolidation)与看板(delegates)双双失真。
4059
+ */
4060
+ if (patch.consolidation === undefined)
4061
+ next.consolidation = undefined;
4062
+ if (patch.delegates === undefined)
4063
+ next.delegates = undefined;
3752
4064
  }
3753
4065
  if (patch.status === 'in_progress') {
3754
4066
  if (next.startedAt === null)
@@ -4669,7 +4981,14 @@ export function buildChildPrompt({ plan, subtask, stage, dependencyResults, cwd,
4669
4981
  * 不注入时的旧行为是让子 Agent 去喊 `"lead"`——那不是任何会话的 id,
4670
4982
  * 真实派发中只会得到 `subagent "lead" is unavailable`。
4671
4983
  */
4672
- leadAgentId = '', leadAgentIdSource = 'none', }) {
4984
+ leadAgentId = '', leadAgentIdSource = 'none',
4985
+ /*
4986
+ * [2.3.9][T4b] 用户强制要求 3:分配任务时必须把要求 1/2 全文告知相关部门。
4987
+ * 注入唯一事实源在 llm-rules.ts(buildLlmRulesBrief,tier='department');
4988
+ * 由派发调用点传入(plan.ts 不能反向 import llm-rules.ts,会造成循环依赖)。
4989
+ * 空串 = 旧调用方(旧测试/旧路径)零变化;新派发链恒传非空。
4990
+ */
4991
+ llmRulesBrief = '', }) {
4673
4992
  const noticeTarget = readLeadAgentId(leadAgentId);
4674
4993
  const noticeCall = leadNoticeCallForm(noticeTarget);
4675
4994
  const noticeTargetLine = noticeTarget
@@ -4812,6 +5131,7 @@ leadAgentId = '', leadAgentIdSource = 'none', }) {
4812
5131
  `全局任务:${understanding.originalRequest ?? '(未记录)'}`,
4813
5132
  `最终交付物:${understanding.deliverable ?? '(未记录)'}`,
4814
5133
  ...anchorBlock,
5134
+ ...(llmRulesBrief ? ['', String(llmRulesBrief), ''] : []),
4815
5135
  `主要矛盾:${contradiction}`,
4816
5136
  `当前阶段:${stageName}(${stageGoal})`,
4817
5137
  `工作目录:${cwd || '(未知)'}`,
package/lib/replan.js CHANGED
@@ -188,7 +188,7 @@ function mergeReplacement(old, replacement, id, reason) {
188
188
  * (T4 D-T4-03)。修复前 add 接受 14 条依赖、200 条 inputs 与 16 万字符
189
189
  * 载荷,这些计划再也回灌不了 validatePlan,却能被真实派发。
190
190
  */
191
- function replanFieldError(raw) {
191
+ function replanFieldError(raw, allowedEfforts) {
192
192
  const list = (key, max, itemMax, required = false) => {
193
193
  const value = raw?.[key];
194
194
  if (value === undefined)
@@ -221,6 +221,10 @@ function replanFieldError(raw) {
221
221
  };
222
222
  /*
223
223
  * [2.2.7][T4/五档+G1] reasoningEffort 入口白名单(replace/add 两路共用本函数):
224
+ * [2.3.9][T3/同步点] 此处按 REASONING_EFFORTS **存储全集五档**校验是刻意决策:
225
+ * 重规划的输入可能来自回放/他模型计划,删档会破坏零迁移契约;模型家族收窄
226
+ * 统一发生在派发入口(runtime.ts 静态收窄 + qwen-rule/non-qwen-rule 留痕)与
227
+ * 规划校验(validatePlan options.allowedEfforts),口径见 plan.ts L214-231 注释。
224
228
  * 与 plan.ts readSubtasks 语义对齐——缺失/显式 null 合法(replace 继承旧行、
225
229
  * add 留给派发期回落 high),非缺失值必须是 REASONING_EFFORTS 五档之一
226
230
  * (low / medium / high / xhigh / max),非法值拒绝、不改写。补上此校验前,
@@ -230,8 +234,15 @@ function replanFieldError(raw) {
230
234
  const effortError = effort === undefined || effort === null
231
235
  ? null
232
236
  : typeof effort !== 'string' || !REASONING_EFFORTS.includes(effort)
233
- ? 'reasoningEffort 必须是 low / medium / high / xhigh / max 之一(缺失合法:replace 继承旧行、add 派发期回落;非法值拒绝,不改写)'
234
- : null;
237
+ ? 'reasoningEffort 必须是 low / medium / high / xhigh / max 之一(缺失合法:replace 继承旧行、add 派发期回落;非法值拒绝,不改写;传入模型家族集合时进一步收窄为该集合)'
238
+ /*
239
+ * [2.3.9][T3] 模型感知收窄口径(用户要求 1/2;与 plan.ts validatePlan、
240
+ * runtime 派发侧同一真源):调用方传入当前模型家族等级集合时,五档合规
241
+ * 但家族越界的档位(如 qwen 系的 high/max)同样拒绝并点名集合,不改写。
242
+ */
243
+ : Array.isArray(allowedEfforts) && allowedEfforts.length > 0 && !allowedEfforts.includes(effort)
244
+ ? `reasoningEffort "${effort}" 不在当前模型家族的推理等级集合 {${allowedEfforts.join(' / ')}} 内(qwen 系仅 low / medium / xhigh;非 qwen 系仅 low / high / max),必须改用集合内档位`
245
+ : null;
235
246
  return list('dependsOn', 12, 16)
236
247
  ?? list('method', 12, 800)
237
248
  ?? list('inputs', 12, 800)
@@ -323,7 +334,7 @@ export function planReplan(plan, changes, options = {}) {
323
334
  if (replacement.department !== undefined && replanDepartment(replacement.department) === null) {
324
335
  return fail(REPLAN_CODES.INVALID_REPLACEMENT, `replacement.department 不是合法部门:${String(replacement.department)}`);
325
336
  }
326
- const replacementError = replanFieldError(replacement);
337
+ const replacementError = replanFieldError(replacement, options?.allowedEfforts);
327
338
  if (replacementError)
328
339
  return fail(REPLAN_CODES.INVALID_REPLACEMENT, `replacement 字段不合规:${replacementError}`);
329
340
  const requestedId = typeof replacement.id === 'string' ? replacement.id.trim() : '';
@@ -382,7 +393,7 @@ export function planReplan(plan, changes, options = {}) {
382
393
  if (department === null) {
383
394
  return fail(REPLAN_CODES.INVALID_SUBTASK, `newSubtask.department 不是合法部门:${String(raw.department)}`);
384
395
  }
385
- const fieldError = replanFieldError(raw);
396
+ const fieldError = replanFieldError(raw, options?.allowedEfforts);
386
397
  if (fieldError)
387
398
  return fail(REPLAN_CODES.INVALID_SUBTASK, `newSubtask 字段不合规:${fieldError}`);
388
399
  const goal = typeof raw.objective === 'string' ? raw.objective.trim() : '';