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/src/plan.ts CHANGED
@@ -10,9 +10,17 @@
10
10
  import { createHash, randomUUID } from 'node:crypto'
11
11
 
12
12
  import { DEPARTMENT_CAPABILITIES, DEPARTMENT_EXPERT_STANDARD, departmentCapability } from './departments.js'
13
+ // [SCv2-T4] 判据层单一真源(Q1–Q7 用户 2026-11-13 裁决 B/B/B/B/A/A/B):
14
+ // 只引入判据层常量/消毒/派生,运行层常量与公式不在本模块改动(Q7-B 红线)。
15
+ import {
16
+ CRITERION_TARGET_MINUTES,
17
+ CRITERION_RESULTS,
18
+ attemptWallClockMsOf,
19
+ sanitizeCriterionException,
20
+ } from './criterion.js'
13
21
  import { MAX_TASK_ANCHOR_CHARS } from './understanding.js'
14
22
  import { isMappingDigest, verifyMappingDigest } from './supersede-digest.js'
15
- import { phaseSummaryLine, threePhasePromptLines, validatePhaseEvidence } from './three-phase.js'
23
+ import { phaseSummaryLine, sanitizeMainDeepThink, threePhasePromptLines, validatePhaseEvidence } from './three-phase.js'
16
24
  import {
17
25
  NOTICE_TARGET_MISSING_TEXT,
18
26
  leadNoticeCallForm,
@@ -24,6 +32,17 @@ import {
24
32
  renderCommFormatRejection,
25
33
  renderCommFormatSpec,
26
34
  } from './comm-format.js'
35
+ // [3.0.0] 用户 2026-11-14 第 1/2/3/4/8/10/11 条的纯逻辑契约(零依赖模块):
36
+ // 两条会话固定文案、质量要求渲染、部门汇总契约。
37
+ import {
38
+ STATUS_ASSIGNED_TEXT,
39
+ STATUS_ASSIGNING_TEXT,
40
+ diceSimilarity,
41
+ isQualityGatePlan,
42
+ normalizeQualityRequirements,
43
+ renderDepartmentSummarySpec,
44
+ renderQualityRequirementsBlock,
45
+ } from './v3-contract.js'
27
46
 
28
47
  export const PLAN_VERSION = 1
29
48
 
@@ -148,7 +167,7 @@ export const CLOSURES = Object.freeze([
148
167
  'replanned',
149
168
  ])
150
169
  /** Why a `blocked` / `escalated` row stopped. Read by the dashboard and result message. */
151
- export const BLOCKED_KINDS = Object.freeze(['failed', 'timeout', 'no-ack', 'escalated', 'comm-format'])
170
+ export const BLOCKED_KINDS = Object.freeze(['failed', 'timeout', 'no-ack', 'escalated', 'comm-format', 'criterion-overrun'])
152
171
  /**
153
172
  * [1.11.0] 合法闭环迁移(T4 §4 的 19 条,M1)。
154
173
  *
@@ -211,6 +230,98 @@ export const LIKELIHOODS = Object.freeze(['low', 'medium', 'high'])
211
230
  export const REASONING_EFFORTS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max'])
212
231
  export const DEFAULT_REASONING_EFFORT = 'high'
213
232
 
233
+ /**
234
+ * [3.0.0][用户要求 9] 部门组员角色已取消——分工表/看板第三层只允许「全球顶尖专家」。
235
+ *
236
+ * 写入侧一律归一到 `expert`:历史计划与历史 journal 里可能存着 `role:'member'`
237
+ * (append-only,不迁移、不改写),若继续按「非 expert 即 member」兜底,
238
+ * 一次状态回写就会把已取消的角色重新写进存档,等于没取消。读取侧对
239
+ * `member` 的兼容由 dept-journal 的只读枚举保留,与本函数互不影响。
240
+ */
241
+ export function normalizeDeptRole(_role: unknown): 'expert' {
242
+ return 'expert'
243
+ }
244
+
245
+ /*
246
+ * [2.3.9][T3] LLM 家族静态规则(用户 2026-11-10 强制要求 1/2,主 Agent 权威口径)。
247
+ *
248
+ * 单一事实源:家族判定与等级集合只在本处定义;runtime(派发/规划入口)、
249
+ * replan(校验)、client(UI Pill)一律从这里取数,禁止第二份表。
250
+ *
251
+ * 用户规则原文:
252
+ * 1. 字母 qwen 开头的模型,推理等级只包括 low、medium、xhigh——轻度任务
253
+ * 使用 low,比较复杂的任务使用 medium,非常复杂的任务使用 xhigh。
254
+ * 2. 非 qwen 开头的其他大模型,推理等级只包括 low、high、max——轻度任务
255
+ * 使用 low,比较复杂的任务使用 high,非常复杂的任务使用 max。
256
+ *
257
+ * 与存储全集的关系(不得删档):REASONING_EFFORTS 五档仍是**存储全集**(计划
258
+ * JSON、序列化回放、旧计划的合法域);本表是**执行前约束**——派发/规划发送
259
+ * 前按当前模型家族收窄,再与宿主能力清单取交集钳制(两段各自留痕)。
260
+ * 模型名缺失 ⇒ classifyModelFamily 返回 null ⇒ 不施加静态约束,保持旧行为
261
+ * (与 [2.2.7]「无从判定⇒不阻断」同风格,防凭空收紧误伤五档全支持模型)。
262
+ */
263
+ export type ModelFamily = 'qwen' | 'other'
264
+ export const QWEN_MODEL_EFFORTS: readonly string[] = Object.freeze(['low', 'medium', 'xhigh'])
265
+ export const OTHER_MODEL_EFFORTS: readonly string[] = Object.freeze(['low', 'high', 'max'])
266
+
267
+ /** 判定模型家族:qwen 开头(trim+小写)→ 'qwen';其余非空 → 'other';空/缺失 → null(不约束)。 */
268
+ export function classifyModelFamily(modelId?: string | null): ModelFamily | null {
269
+ const normalized = String(modelId ?? '').trim().toLowerCase()
270
+ if (!normalized) return null
271
+ return normalized.startsWith('qwen') ? 'qwen' : 'other'
272
+ }
273
+
274
+ /** 家族 → 允许等级集合(用户要求 1/2 硬白名单);未知家族 → null = 不施加约束。 */
275
+ export function effortsForModelFamily(family?: ModelFamily | null): readonly string[] | null {
276
+ if (family === 'qwen') return QWEN_MODEL_EFFORTS
277
+ if (family === 'other') return OTHER_MODEL_EFFORTS
278
+ return null
279
+ }
280
+
281
+ /** 一步式:按模型 id 得到等级集合;模型名缺失返回 null(不约束)。 */
282
+ export function allowedEffortsForModel(modelId?: string | null): readonly string[] | null {
283
+ return effortsForModelFamily(classifyModelFamily(modelId))
284
+ }
285
+
286
+ /**
287
+ * 复杂度 → 档位映射表(要求 1/2 的「轻度/比较复杂/非常复杂」数值化;
288
+ * 部门负责人与专家/组员选档的官方依据,要求 5)。
289
+ */
290
+ export type TaskComplexity = 'light' | 'moderate' | 'heavy'
291
+ export const COMPLEXITY_EFFORT_BY_FAMILY: Readonly<Record<ModelFamily, Record<TaskComplexity, string>>> =
292
+ Object.freeze({
293
+ qwen: Object.freeze({ light: 'low', moderate: 'medium', heavy: 'xhigh' }),
294
+ other: Object.freeze({ light: 'low', moderate: 'high', heavy: 'max' }),
295
+ })
296
+
297
+ /** 按家族+复杂度取应使用档位;家族未知返回 null。 */
298
+ export function effortForComplexity(family: ModelFamily | null, complexity: TaskComplexity): string | null {
299
+ if (!family) return null
300
+ return COMPLEXITY_EFFORT_BY_FAMILY[family][complexity]
301
+ }
302
+
303
+ /**
304
+ * [3.0.0] 推理强度序单一真源(off < minimal < low < medium < high < xhigh < max)。
305
+ *
306
+ * 旧实现有三份逐字相同的副本(plan.ts 内联数组 / llm-rules.ts STATIC_STRENGTH_ORDER /
307
+ * runtime.ts EFFORT_STRENGTH_ORDER),改一处漏两处必然分叉。此处导出为唯一真源:
308
+ * llm-rules 已改从本模块导入;runtime.ts 的副本请同样改为
309
+ * `import { EFFORT_STRENGTH_ORDER } from './plan.js'`(由主代理转告 runtime 负责人)。
310
+ */
311
+ export const EFFORT_STRENGTH_ORDER: readonly string[] = Object.freeze(
312
+ ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
313
+ )
314
+
315
+ /** 集合内最高档(强度序见 EFFORT_STRENGTH_ORDER);空集合返回 null。 */
316
+ export function highestEffortOf(levels: readonly string[] | null): string | null {
317
+ if (!levels || levels.length === 0) return null
318
+ let best: string | null = null
319
+ for (const id of levels) {
320
+ if (best === null || EFFORT_STRENGTH_ORDER.indexOf(id) > EFFORT_STRENGTH_ORDER.indexOf(best)) best = id
321
+ }
322
+ return best
323
+ }
324
+
214
325
  export const DEPARTMENTS = Object.freeze({
215
326
  engineering: { zh: '工程研发', en: 'Engineering' },
216
327
  research: { zh: '研究分析', en: 'Research' },
@@ -752,6 +863,42 @@ function readSubtasks(value: any, stageIndex: any, errors: any) {
752
863
  if (hasEstimate && !estimateOk) {
753
864
  push(errors, `${base}.estimateMinutes`, '必须是 1-240 的整数(仅防离谱值:越界或非整数拒绝、不改写;该字段可选,缺失合法)')
754
865
  }
866
+ /*
867
+ * [SCv2-T4][Q2-B/C09/C10] 估时 >10 软门禁(GAP-1 消解:用户裁决 Q2=B 明确
868
+ * 「缺失时不拒绝(软门禁)」,AC-Q3-1 的「不存在超 10 无说明行」按「必须被
869
+ * 标记点名、不得显示达标」实现,不做硬拒绝——硬拒绝会推翻既有回归
870
+ * tests/time-estimate-negotiation.test.ts B2/O-2b(90/240 必须通过)。
871
+ * 1–240 区间与拒因文案零改动;叶子 1..10080 五处定义一处不改(C13 红线)。
872
+ * splitReason(拆分说明)/ estimateConfirm(用户确认留痕)二者其一即可
873
+ * 消除「需补说明」标记;标记只观测、不阻断(estimateOverCriterion /
874
+ * estimateNeedsJustification 仅在触发时下发,旧计划载荷逐字不变)。
875
+ */
876
+ if (source.splitReason !== undefined && source.splitReason !== null && typeof source.splitReason !== 'string') {
877
+ push(errors, `${base}.splitReason`, '必须是字符串(拆分说明:为什么不能拆到 ≤10 分钟;可选字段,缺失合法)')
878
+ }
879
+ const splitReasonText = typeof source.splitReason === 'string' ? source.splitReason.trim() : ''
880
+ let estimateConfirm: { confirmed: boolean; by?: string; at?: number; reason?: string } | null = null
881
+ if (source.estimateConfirm !== undefined && source.estimateConfirm !== null) {
882
+ if (!isRecord(source.estimateConfirm) || typeof source.estimateConfirm.confirmed !== 'boolean') {
883
+ push(errors, `${base}.estimateConfirm`, '必须是对象 { confirmed: boolean, by?, at?, reason? }(用户确认留痕,可选字段,缺失合法)')
884
+ } else {
885
+ const confirmAt = Number(source.estimateConfirm.at)
886
+ estimateConfirm = {
887
+ confirmed: source.estimateConfirm.confirmed,
888
+ ...(typeof source.estimateConfirm.by === 'string' && source.estimateConfirm.by.trim() !== ''
889
+ ? { by: truncate(source.estimateConfirm.by.trim(), 200) }
890
+ : {}),
891
+ ...(Number.isFinite(confirmAt) && confirmAt > 0 ? { at: confirmAt } : {}),
892
+ ...(typeof source.estimateConfirm.reason === 'string' && source.estimateConfirm.reason.trim() !== ''
893
+ ? { reason: truncate(source.estimateConfirm.reason.trim(), 800) }
894
+ : {}),
895
+ }
896
+ }
897
+ }
898
+ const estimateOverCriterion = estimateOk && estimateValue > CRITERION_TARGET_MINUTES
899
+ const estimateNeedsJustification = estimateOverCriterion
900
+ && splitReasonText === ''
901
+ && !(estimateConfirm && estimateConfirm.confirmed === true)
755
902
  /*
756
903
  * [2.2.0][T3/O-3a] per-subtask 协商上限(timeoutMs,毫秒)可选透传。
757
904
  *
@@ -785,6 +932,15 @@ function readSubtasks(value: any, stageIndex: any, errors: any) {
785
932
  if (hasEffort && !effortOk) {
786
933
  push(errors, `${base}.reasoningEffort`, '必须是 low / medium / high / xhigh / max 之一(可选字段,缺失时回落 high;非法值拒绝,不改写)')
787
934
  }
935
+ /*
936
+ * [3.0.0][用户要求 3] qualityRequirements:数组或单个字符串均可,空项丢弃、
937
+ * 去重、按 8 条 × 400 字符截断;全部为空则视为缺失(不拒绝)。
938
+ */
939
+ const qualityRequirements = normalizeQualityRequirements(source.qualityRequirements)
940
+ if (source.qualityRequirements !== undefined && source.qualityRequirements !== null
941
+ && !Array.isArray(source.qualityRequirements) && typeof source.qualityRequirements !== 'string') {
942
+ push(errors, `${base}.qualityRequirements`, '必须是字符串数组(主 Agent 对结果的质量要求;新计划必填:派发时缺失的子任务将被直接拒发 DISPATCH_QUALITY_REQUIREMENTS_MISSING,须 replan 补齐后重派;旧计划缺失合法,回落验收标准)')
943
+ }
788
944
  return {
789
945
  id: readString(source.id, `${base}.id`, 1, 16, errors),
790
946
  title: readString(source.title, `${base}.title`, 1, 200, errors),
@@ -803,6 +959,12 @@ function readSubtasks(value: any, stageIndex: any, errors: any) {
803
959
  */
804
960
  dependsOn: readStringArray(source.dependsOn, `${base}.dependsOn`, { min: 0, max: MAX_SUBTASKS - 1, itemMax: 16 }, errors),
805
961
  acceptance: readStringArray(source.acceptance, `${base}.acceptance`, { min: 1, max: 8, itemMax: 800 }, errors),
962
+ /*
963
+ * [3.0.0][用户要求 3] 主 Agent 派发给部门负责人时附带的「结果质量要求」。
964
+ * 新计划由规划器逐条写出;缺失时不拒绝(旧计划与回放零回归),由
965
+ * buildChildPrompt 回落为「验收标准即质量要求」并在块标题里如实写明来源。
966
+ */
967
+ ...(qualityRequirements.length > 0 ? { qualityRequirements } : {}),
806
968
  risk: readString(source.risk, `${base}.risk`, 1, 1000, errors),
807
969
  /*
808
970
  * [1.12.0] Optional: why this department was chosen. The planner prompt
@@ -823,6 +985,11 @@ function readSubtasks(value: any, stageIndex: any, errors: any) {
823
985
  * [1.7.0] 历史记录。
824
986
  */
825
987
  ...(estimateOk ? { estimateMinutes: estimateValue } : {}),
988
+ // [SCv2-T4][Q2-B] 软门禁标记与留痕:仅在触发/存在时下发(旧计划载荷不变)。
989
+ ...(estimateOverCriterion ? { estimateOverCriterion: true } : {}),
990
+ ...(estimateNeedsJustification ? { estimateNeedsJustification: true } : {}),
991
+ ...(splitReasonText !== '' ? { splitReason: truncate(splitReasonText, 800) } : {}),
992
+ ...(estimateConfirm ? { estimateConfirm } : {}),
826
993
  ...(timeoutOk ? { timeoutMs: timeoutValue } : {}),
827
994
  // [2.2.7][T4/五档] 缺省回落保持 high(DEFAULT_REASONING_EFFORT,D1 决策):
828
995
  // 白名单由三档扩为五档(low / medium / high / xhigh / max)后,high 仍是
@@ -1020,32 +1187,143 @@ function checkPlanGraph(plan: any, errors: string[]) {
1020
1187
  }
1021
1188
  }
1022
1189
 
1190
+ /**
1191
+ * [2.5.5][治本] 规划器原始输出归一化(用户 2026-11-12 决断:修复自动分解
1192
+ * 反复降级的缺陷)。旧 [2.3.9] 对「集合外但五档合法」的 reasoningEffort、
1193
+ * 超上限 anchors、非字符串数组字段一律**拒绝**,规划器连续 3 次写同样值
1194
+ * 即整轮降级(本会话两次现场:high@qwen ×3、anchors>40、outputs 非数组)。
1195
+ * 治本=在校验前单点归一化并留痕,能自动纠正的不再烧重试:
1196
+ * 1. reasoningEffort:五档合法但越家族集合 ⇒ 按强度序就近向下归一到集合内
1197
+ * (high@qwen→medium、max@qwen→xhigh、xhigh@非qwen→high、medium@非qwen→low,
1198
+ * 与 correctEffortForModel 同口径);五档非法值仍交 readSubtasks 拒绝/回落。
1199
+ * 2. anchors:>40 ⇒ 截断到 40(上限本意是防刷屏,不是否决计划)。
1200
+ * 3. 字符串数组字段:字符串⇒[字符串];数组内非字符串元素⇒String/JSON.stringify。
1201
+ * 不改变任何合法值;未传 allowedEfforts 时不做家族归一(回放零迁移)。
1202
+ * 返回 notes 供调用方留痕(计划 normalizations 字段/遥测)。
1203
+ */
1204
+ export function normalizePlanRaw(raw: any, allowedEfforts?: readonly string[] | null): { raw: any; notes: string[] } {
1205
+ const notes: string[] = []
1206
+ if (!isRecord(raw)) return { raw, notes }
1207
+ const out: any = { ...raw }
1208
+ let changed = false
1209
+ const coerceStringArray = (value: any, path: string): any => {
1210
+ if (typeof value === 'string' && value.trim() !== '') {
1211
+ notes.push(`${path}: 字符串→[字符串](自动归一留痕)`)
1212
+ return [value]
1213
+ }
1214
+ if (Array.isArray(value) && value.some((item) => typeof item !== 'string')) {
1215
+ notes.push(`${path}: 非字符串元素→字符串(自动归一留痕)`)
1216
+ return value
1217
+ .map((item) => (typeof item === 'string' ? item : item === null || item === undefined ? '' : typeof item === 'object' ? JSON.stringify(item) : String(item)))
1218
+ .filter((item) => item !== '')
1219
+ }
1220
+ return value
1221
+ }
1222
+ if (Array.isArray(raw.stages)) {
1223
+ let stagesChanged = false
1224
+ const stages = raw.stages.map((stage: any, stageIndex: number) => {
1225
+ if (!isRecord(stage) || !Array.isArray(stage.subtasks)) return stage
1226
+ let subtasksChanged = false
1227
+ const subtasks = stage.subtasks.map((subtask: any, subtaskIndex: number) => {
1228
+ if (!isRecord(subtask)) return subtask
1229
+ const base = `stages[${stageIndex}].subtasks[${subtaskIndex}]`
1230
+ let next: any = subtask
1231
+ let localChanged = false
1232
+ const effort = subtask.reasoningEffort
1233
+ if (allowedEfforts && typeof effort === 'string' && !allowedEfforts.includes(effort)) {
1234
+ const idx = REASONING_EFFORTS.indexOf(effort)
1235
+ if (idx >= 0) {
1236
+ let target: string | null = null
1237
+ for (let i = idx; i >= 0; i -= 1) {
1238
+ if (allowedEfforts.includes(REASONING_EFFORTS[i])) { target = REASONING_EFFORTS[i]; break }
1239
+ }
1240
+ if (target === null) target = allowedEfforts[0]
1241
+ if (target !== effort) {
1242
+ notes.push(`${base}.reasoningEffort: ${effort}→${target}(模型家族自动归一留痕)`)
1243
+ next = { ...next, reasoningEffort: target }
1244
+ localChanged = true
1245
+ }
1246
+ }
1247
+ }
1248
+ for (const key of ['method', 'inputs', 'outputs', 'acceptance', 'dependsOn']) {
1249
+ const coerced = coerceStringArray(subtask[key], `${base}.${key}`)
1250
+ if (coerced !== subtask[key]) {
1251
+ next = { ...next, [key]: coerced }
1252
+ localChanged = true
1253
+ }
1254
+ }
1255
+ if (localChanged) subtasksChanged = true
1256
+ return next
1257
+ })
1258
+ if (!subtasksChanged) return stage
1259
+ stagesChanged = true
1260
+ return { ...stage, subtasks }
1261
+ })
1262
+ if (stagesChanged) { out.stages = stages; changed = true }
1263
+ }
1264
+ if (isRecord(raw.taskUnderstanding)) {
1265
+ const tu: any = { ...raw.taskUnderstanding }
1266
+ let tuChanged = false
1267
+ if (Array.isArray(tu.anchors) && tu.anchors.length > 40) {
1268
+ notes.push(`taskUnderstanding.anchors: ${tu.anchors.length}→40(上限截断留痕)`)
1269
+ tu.anchors = tu.anchors.slice(0, 40)
1270
+ tuChanged = true
1271
+ }
1272
+ for (const key of ['successCriteria', 'constraints', 'knownFacts', 'unknowns', 'assumptions', 'anchors']) {
1273
+ const coerced = coerceStringArray(tu[key], `taskUnderstanding.${key}`)
1274
+ if (coerced !== tu[key]) { tu[key] = coerced; tuChanged = true }
1275
+ }
1276
+ if (tuChanged) { out.taskUnderstanding = tu; changed = true }
1277
+ }
1278
+ return { raw: changed ? out : raw, notes }
1279
+ }
1280
+
1023
1281
  /**
1024
1282
  * Validate an untrusted planner object. Never throws for malformed input.
1025
1283
  *
1026
- * @param {unknown} raw
1027
- * @returns {{ok: true, plan: object} | {ok: false, errors: string[]}}
1284
+ * [2.3.9][T3] options.allowedEfforts:当前模型家族的等级集合(真源
1285
+ * allowedEffortsForModel)。[2.5.5] 起集合外但五档合法的档位不再拒绝,而是
1286
+ * 经 normalizePlanRaw 就近归一并留痕(治本:规划器重复写 high@qwen 不再烧
1287
+ * 三次重试后降级);五档非法值仍拒绝。null/未传 ⇒ 不施加家族归一(回放、旧
1288
+ * 调用零行为变化)。REASONING_EFFORTS 五档仍是存储全集,不得删档。
1028
1289
  */
1029
- export function validatePlan(raw: any) {
1290
+ export function validatePlan(raw: any, options?: { allowedEfforts?: readonly string[] | null }) {
1030
1291
  if (!isRecord(raw)) {
1031
- return { ok: false, errors: ['计划必须是 JSON 对象'] }
1292
+ return { ok: false, errors: ['计划必须是 JSON 对象'], notes: [] }
1032
1293
  }
1294
+ const allowedEfforts = options && options.allowedEfforts ? options.allowedEfforts : null
1295
+ const normalized = normalizePlanRaw(raw, allowedEfforts)
1296
+ const source = normalized.raw
1033
1297
  const errors: string[] = []
1034
- if (raw.version !== PLAN_VERSION) errors.push(`version: 必须为 ${PLAN_VERSION}`)
1298
+ if (source.version !== PLAN_VERSION) errors.push(`version: 必须为 ${PLAN_VERSION}`)
1035
1299
  const plan = {
1036
1300
  version: PLAN_VERSION,
1037
- title: readString(raw.title, 'title', 1, 200, errors),
1038
- taskAnchor: readTaskAnchor(raw.taskAnchor),
1039
- taskUnderstanding: readTaskUnderstanding(raw.taskUnderstanding, errors),
1040
- contradictions: readContradictions(raw.contradictions, errors),
1041
- stages: readStages(raw.stages, errors),
1042
- risks: readRisks(raw.risks, errors),
1043
- verification: readVerification(raw.verification, errors),
1044
- practiceLoop: readPracticeLoop(raw.practiceLoop, errors),
1301
+ title: readString(source.title, 'title', 1, 200, errors),
1302
+ taskAnchor: readTaskAnchor(source.taskAnchor),
1303
+ taskUnderstanding: readTaskUnderstanding(source.taskUnderstanding, errors),
1304
+ contradictions: readContradictions(source.contradictions, errors),
1305
+ stages: readStages(source.stages, errors),
1306
+ risks: readRisks(source.risks, errors),
1307
+ verification: readVerification(source.verification, errors),
1308
+ practiceLoop: readPracticeLoop(source.practiceLoop, errors),
1309
+ }
1310
+ /*
1311
+ * [3.0.0] 质量要求必填门禁(用户要求 3/6,与派发期 checkSubtaskQualityRequirements
1312
+ * 同口径):激活时刻(v3-contract QUALITY_GATE_ACTIVATED_AT)之后创建的新计划,
1313
+ * 读档/回放重新走 validatePlan 时,缺失 qualityRequirements 的子任务直接拒绝;
1314
+ * 激活时刻前的历史计划由 isQualityGatePlan 豁免(createdAt 缺失/非法一律视为
1315
+ * 旧计划放行),零回归。
1316
+ */
1317
+ if (isQualityGatePlan(source)) {
1318
+ for (const { subtask } of flattenSubtasks(plan)) {
1319
+ if (!Array.isArray(subtask.qualityRequirements) || subtask.qualityRequirements.length === 0) {
1320
+ errors.push(`子任务 ${subtask.id}(${subtask.title})缺 qualityRequirements:激活时刻后的新计划必填质量要求(与派发期门禁同口径 DISPATCH_QUALITY_REQUIREMENTS_MISSING),须 replan 补齐后重派`)
1321
+ }
1322
+ }
1045
1323
  }
1046
1324
  checkPlanGraph(plan, errors)
1047
- if (errors.length > 0) return { ok: false, errors }
1048
- return { ok: true, plan }
1325
+ if (errors.length > 0) return { ok: false, errors, notes: normalized.notes }
1326
+ return { ok: true, plan, notes: normalized.notes }
1049
1327
  }
1050
1328
 
1051
1329
  export function attachPlanMeta(plan: any, meta: any) {
@@ -1415,21 +1693,28 @@ export function buildPlannerPrompt(taskText: any, cwd: any, conversationContext:
1415
1693
  '- department 必须从下面的部门中选择一个;必须同时写 departmentRationale(1-2 句,引用该部门职责与任务要素),department 与 rationale 不一致的计划视为不合格。',
1416
1694
  '- method、outputs、acceptance 必须是非空数组;inputs 可以为空,未知写“待确认”。',
1417
1695
  '- unknowns 和 assumptions 必须如实列出;没有就写空数组,不能把假设写成事实。',
1418
- '- 子任务必须可独立执行、可验收;不要为了凑数拆无意义任务。',
1419
- '- 子任务由子 Agent 独立执行:它们没有派发权限、不能重启服务、不能安装或升级依赖。禁止把「调用 dsh_workplan_dispatch」「重启/停止 dsh web」「安装或升级插件」这类只有主 Agent 才能执行的动作写进子任务;确实需要时,写成“给出结论或建议,由主 Agent 执行”。',
1420
- '- 单个子任务无须在 10 分钟内完成——10 分钟只是拆步规模建议,不是完成期限、也不构成承诺;实际时长由执行专家开工预告协商决定,不设固定完成时间;动手重的任务要拆成多个小步,避免整条计划被一个慢子任务拖住。',
1696
+ '- 子任务必须可独立执行、可验收;不要为了凑数拆无意义任务;10 分钟内(判据层完成目标)不能完美完成的任务必须在规划阶段事前拆小(拆分优先),不得以「要完美完成」为由保留大任务。',
1697
+ // [2.5.0] 用户要求 3:分解必须更简单。部门负责人拥有本部门内再分配权限
1698
+ // (dsh_workplan_delegate),会把子任务再拆给多名顶尖专家与组员,因此
1699
+ // 主计划层保持单一目标/单一主产物的简单子任务,执行细节下沉到部门内分工。
1700
+ '- 分解必须更简单(用户强制要求):每个子任务只写单一目标、单一主产物、可独立验收的一件事;不要把多个交付物压进同一个子任务。部门负责人接到子任务后,会用 dsh_workplan_delegate 把它再拆成更简单的单项工作,分配给本部门多名相关领域全球顶尖专家共同承担(部门组员角色已按用户要求 9 取消)——所以主计划子任务保持简单清晰即可,执行细节由部门内分工细化,不要越俎代庖替部门预拆全部细节。再分配同样遵守拆分优先:部门负责人须把本行再拆到每项 10 分钟内,并把本行全部叶子的开工预估之和控制在 ≤10 分钟;预估未报齐时只显示部分和,不得视为达标。',
1701
+ '- 子任务由部门负责人子 Agent 牵头执行:负责人拥有本部门内的再分配权限(dsh_workplan_delegate,先 review 提交两轮深度思考产物后 dispatch 派给本部门专家(只保留 expert 角色)),但没有主计划派发权限、不能重启服务、不能安装或升级依赖。禁止把「调用 dsh_workplan_dispatch」「重启/停止 dsh web」「安装或升级插件」这类只有主 Agent 才能执行的动作写进子任务;确实需要时,写成“给出结论或建议,由主 Agent 执行”。',
1702
+ '- 判据层(完成目标 ≤10 分钟,默认必须达成):每个子任务都要在 10 分钟内做完;10 分钟内做不完的任务必须在规划阶段事前拆小,不得以「要完美完成」为由保留大任务。',
1703
+ '- 运行层安全兜底(不是固定交付期限、不构成对外承诺,也不构成「允许慢」的许可):单次执行时限=clamp(estimateMinutes×2.0, 1 秒, 120 分钟),到点走安全兜底结算保证不丢产物;确需超过 10 分钟的唯一合法例外是用户明确批准并留痕(任务 ID、批准原文/来源、批准时间、放宽后分钟数、适用范围;无留痕=未批准);未获批准的超时不得以 done 收尾,记「判据违规(criterion-overrun)」并转新子任务续做。',
1704
+ '- 生效时点(不回溯):本判据自用户 2026-11-13 裁决(B/B/B/B/A/A/B)生效;运行态判定自补丁部署+用户重启+复核通过后新创建的计划起执行;此前已验收为 done 的历史任务与在途计划按旧规则,不重判、不重跑、不改验收结论。',
1421
1705
  // [2.3.2][D2-P2] 半角/逗号/括号自检硬约束:与解析层兜底(P0)互为防线,中文模型全角标点高发。
1422
1706
  '- JSON 只允许半角标点(, : " { } [ ]);对象与数组的相邻成员之间必须有逗号;输出前自检括号成对、每个字符串以半角"闭合。',
1423
1707
  '- 不要输出 Markdown 代码围栏、解释或前后缀;只输出一个 JSON 对象。',
1424
1708
  '',
1425
1709
  '本轮时间预算(硬事实,请据此规划规模):',
1426
1710
  totalMinutes > 0
1427
- ? `- 一轮总预算约 ${totalMinutes} 分钟(安全兜底,不是交付期限);单个子任务规模参考 ${childMinutes} 分钟量级(仅供参考、非承诺,实际时长由执行专家开工预告协商决定);同时最多 ${concurrency} 个子任务并行。`
1711
+ ? `- 一轮总预算约 ${totalMinutes} 分钟(运行层安全兜底,不是交付期限);判据层完成目标 ≤10 分钟;运行层规模参考 ${childMinutes} 分钟量级(仅供参考、非承诺,实际时长由执行专家开工预告协商决定),两个数字分属两层、不得混读;同时最多 ${concurrency} 个子任务并行。`
1428
1712
  : `- 本轮不设固定总预算;单个子任务按自身 estimateMinutes 与协商截止/延期执行;同时最多 ${concurrency} 个子任务并行。`,
1429
1713
  resumes > 0
1430
1714
  ? `- 受阻后自动续跑额度 ${resumes} 次;需要时计划会暂停并在下一轮继续。`
1431
1715
  : '- 自动续跑额度为 0;计划不会因轮次预算被暂停。',
1432
- '- 每个子任务必须写 estimateMinutes(整数 1-240,宁可估高):你预估它需要多少分钟。宁可估高,不要估低。取值必须是整数,越界或非整数会被校验拒绝(仅防离谱值),缺失不报错。',
1716
+ '- [3.0.0][用户要求 3/5] 每个子任务必须写 qualityRequirements(1-8 条字符串):这是主 Agent 派给部门负责人时随任务书一起下达的「结果质量要求」,写清成果必须达到什么要求、什么算合格。缺失质量要求的子任务在派发时会被系统直接拒发(DISPATCH_QUALITY_REQUIREMENTS_MISSING,不启动部门 Agent),必须 replan 补齐后重新派发。同时子任务必须是简单到 1+1=2 的单项工作:一个目标、一个主产物、一项可独立验收;不要在一个子任务里塞并列的多件事(出现「并且/同时/另外/还要/以及/分别/顺便」或多句并列时应拆成多个子任务)。',
1717
+ '- 每个子任务必须写 estimateMinutes(整数 1-240,宁可估高):你预估它需要多少分钟。宁可估高,不要估低。取值必须是整数,越界或非整数会被校验拒绝(仅防离谱值),缺失不报错。估时与判据是两层:estimateMinutes 区间保留 1-240(不压缩到 10),宁可估高是事前信号、不是免责;estimateMinutes >10 的子任务必须同时写拆分说明(为什么不能拆到 ≤10 分钟)或用户确认留痕——缺失不拒绝(软门禁),但状态与回报必须标记「需补拆分说明或用户确认」,且不得显示「简单判据达标」。',
1433
1718
  /*
1434
1719
  * [2.2.0][T13/推理等级] 子 Agent 必须自决推理等级,禁止继承主 Agent。
1435
1720
  * 用户规则原文见 plan.ts 顶部 REASONING_EFFORTS 注释;五档映射与五个示例
@@ -1500,6 +1785,7 @@ export function buildPlannerPrompt(taskText: any, cwd: any, conversationContext:
1500
1785
  ' "inputs": ["输入;未知写待确认"],',
1501
1786
  ' "outputs": ["输出/交付物"],',
1502
1787
  ' "dependsOn": [],',
1788
+ ' "qualityRequirements": ["必填:主 Agent 对这条任务结果的质量要求(可检查,1-8 条;缺失该子任务将被拒发)"],',
1503
1789
  ' "acceptance": ["可测试的验收标准"],',
1504
1790
  ' "risk": "主要风险",',
1505
1791
  ' "estimateMinutes": 5,',
@@ -1561,6 +1847,87 @@ function userMessageShapeProblem(message: any): string | null {
1561
1847
  return null
1562
1848
  }
1563
1849
 
1850
+ /*
1851
+ * [2.5.3] 重启后会话损坏治本(用户 2026-11-12 报告:Harness 重启后多个会话
1852
+ * 报 SessionFormatError: system/message requires a protected first surface head)。
1853
+ *
1854
+ * 根因:v4 会话日志校验器要求「当前 surface 的第一个事件必须是受保护的
1855
+ * system/message 头」(dsh-session-persistence-jsonl Relationships.foldSurface:
1856
+ * surface 非空且 protectedHead 未设时再遇 system/message 即抛错)。宿主的系统头
1857
+ * 在首个 model step 才写入;而本插件的【规划预告】/【规划进行中】等通知在首个
1858
+ * step 之前(规划期)就经 appendUserMessage 以 user/message surfaceOp:'append'
1859
+ * 落到 surface 上,抢在系统头之前成为首批 surface 事件。运行期不校验故看似正常,
1860
+ * 重启回放校验时即整会话判损坏——凡首回合带规划通知的会话全部中招(多会话共性)。
1861
+ *
1862
+ * 治本(单点、覆盖全部调用方):唯一合规写入器在「受保护系统头尚未出现」时
1863
+ * 不把通知落到 surface,而是暂存;一旦系统头已存在,先按序补发暂存通知再写当前
1864
+ * 通知。由此保证 surface 上永远不会有先于系统头的 user/message,重启校验通过。
1865
+ * 规划期的可见性由既有侧栏占位卡(通道 A)保底;聊天通知在系统头落地后即刻补发,
1866
+ * 不丢内容、不改事件类型、不触碰 system/message。
1867
+ */
1868
+ const preHeadNoticeQueue = new WeakMap<object, any[]>()
1869
+ const surfaceHeadSeen = new WeakSet<object>()
1870
+ /*
1871
+ * [2.5.5][T3] pre-step 规划/自动派发窗口标记:该窗口是唯一可能产生「头前
1872
+ * surface 写入」的真实宿主路径(maybePlan 在首 step 系统头之前运行)。窗口内
1873
+ * 的所有 appendUserMessage 自动暂存,无需调用方逐个声明。
1874
+ */
1875
+ const preHeadWindowSessions = new WeakSet<object>()
1876
+ export function enterPreHeadWindow(session: any) {
1877
+ if (session && typeof session === 'object') preHeadWindowSessions.add(session)
1878
+ }
1879
+
1880
+ /** 会话 surface 是否已出现受保护系统头(首个 system/message)。只读、单调缓存。 */
1881
+ function surfaceHeadExists(session: any): boolean {
1882
+ if (surfaceHeadSeen.has(session)) return true
1883
+ // 单元桩没有事件回看能力时保持旧行为(直接 append),真实宿主必有 eventAt/seq。
1884
+ if (typeof session.eventAt !== 'function' || !Number.isFinite(Number(session.seq))) return true
1885
+ const total = Math.min(Math.floor(Number(session.seq)), 100000)
1886
+ for (let seq = 0; seq < total; seq += 1) {
1887
+ const event = session.eventAt(seq)
1888
+ if (event && event.type === 'system/message') {
1889
+ surfaceHeadSeen.add(session)
1890
+ return true
1891
+ }
1892
+ }
1893
+ return false
1894
+ }
1895
+
1896
+ /** 系统头已存在时,按序补发规划期暂存的通知(均已通过形状校验)。 */
1897
+ function flushPreHeadNotices(session: any) {
1898
+ const queue = preHeadNoticeQueue.get(session)
1899
+ if (!queue || queue.length === 0) return
1900
+ // 头未就绪绝不补发(否则又把通知写到 head 之前);等 head 落地后的下一次写入再补。
1901
+ if (!surfaceHeadExists(session)) return
1902
+ preHeadNoticeQueue.delete(session)
1903
+ for (const message of queue) session.append('user/message', message, { surfaceOp: 'append' })
1904
+ }
1905
+
1906
+ /*
1907
+ * [2.5.5][治本] 头落地自动补发保险丝:旧实现只在「下一次 appendUserMessage」
1908
+ * 时补发暂存通知——若首回合规划降级后用户不再触发插件写入,暂存通知永远不
1909
+ * 可见(进度全程显示缺口)。这里在首次暂存时启动一个**有界**轮询(2s × 300
1910
+ * = 10 分钟上限,unref 不驻留进程):头一落地立即按序补发并自停;超限自停。
1911
+ * 与 2.2.8/2.2.9 计时器收束纪律一致:任何路径都终止,绝不残留无限定时器。
1912
+ */
1913
+ const preHeadFlushTimers = new WeakMap<object, any>()
1914
+ function schedulePreHeadFlush(session: any) {
1915
+ if (preHeadFlushTimers.has(session)) return
1916
+ let ticks = 0
1917
+ // 卫生类句柄(flushPoll):只负责补发可见通知,不驱动任何终态;有界自停 +
1918
+ // unref(已登记 tests/handle-policy.test.ts 卫生白名单)。
1919
+ const flushPoll = setInterval(() => {
1920
+ ticks += 1
1921
+ if (surfaceHeadExists(session)) flushPreHeadNotices(session)
1922
+ if (surfaceHeadExists(session) || ticks >= 300) {
1923
+ clearInterval(flushPoll)
1924
+ preHeadFlushTimers.delete(session)
1925
+ }
1926
+ }, 2000)
1927
+ flushPoll.unref()
1928
+ preHeadFlushTimers.set(session, flushPoll)
1929
+ }
1930
+
1564
1931
  /**
1565
1932
  * [2.2.1] The single approved writer for `user/message` events in this plugin.
1566
1933
  *
@@ -1569,8 +1936,212 @@ function userMessageShapeProblem(message: any): string | null {
1569
1936
  * shape-checked. Either way a malformed payload throws BEFORE `session.append`,
1570
1937
  * so a bad notice can never corrupt a session log again. All appends use
1571
1938
  * `surfaceOp: 'append'`, matching the previous call sites.
1939
+ *
1940
+ * [2.5.3] additionally defers any notice that would land on the surface before
1941
+ * the protected system head exists (see surfaceHeadExists / flushPreHeadNotices),
1942
+ * so replay-after-restart validation can never see a pre-head user/message.
1943
+ */
1944
+ /*
1945
+ * ================= [T7] 关键进度注入收敛(用户 2026-11-13 23:23 裁决) =================
1946
+ * 基线:reports/T6_requirements_acceptance_baseline.md(C1–C6)+
1947
+ * reports/T5_keyprogress_spec.md;信封载体=用户 2026-11-14 10:04 批准的选项 A
1948
+ * (基线 §8):全量 JSON 信封移入消息既有元数据位 source.durable(additive
1949
+ * 可选键),不重命名/删除任何现有字段、旧消息零迁移、parse 先读元数据回退旧
1950
+ * 文本标记。本闸门只做三件事:
1951
+ * 1) 事件过滤:C2 禁止清单(心跳/预告/预估上报等过程通知)整条不注入;
1952
+ * durable 信封类消息(update/replan/cancel/result/change)的可见文本由
1953
+ * 各自 builder 裁剪,信封随 source.durable 落盘保证回放兼容(C4)。
1954
+ * 2) 单条上限 500 字符(C3):超出截断+按需查询指针;截断优先级由 builder
1955
+ * 保证(状态/阻塞原因/下一步在前,标题等修饰在后)。
1956
+ * 3) 整轮累计上限 4000 字符(C3):roundKey=`planId:dispatchedAt`,派发时
1957
+ * resetRoundInjectionBudget 显式重置;达上限后新事件压缩为极简一行。
1958
+ * 豁免(运营必需,非进度通知):计划定义消息(含 PLAN_MARKER,用户必须看到
1959
+ * 计划全文且回放依赖)、workplan-change(用户变更原文)、指示/followup 等
1960
+ * P2 运营消息(不经本闸门)。工具返回一律不裁(按需通道,C4/F8)。
1572
1961
  */
1573
- export function appendUserMessage(session: any, payload: any, source?: any) {
1962
+ export const KEY_PROGRESS_SINGLE_LIMIT = 500
1963
+ export const KEY_PROGRESS_ROUND_LIMIT = 4000
1964
+ const KEY_PROGRESS_POINTER = '(详见按需查询:dsh_workplan_status/计划台账/reports 产物)'
1965
+ const KEY_PROGRESS_BUDGET_POINTER = '(本轮注入预算用尽,详见按需查询:dsh_workplan_status/reports 产物)'
1966
+
1967
+ const roundInjectionBudget = new WeakMap<object, { roundKey: string; used: number }>()
1968
+
1969
+ /** 派发开轮时重置整轮注入预算(runtime.dispatchPlan / 自动派发各调一次)。 */
1970
+ export function resetRoundInjectionBudget(session: any, roundKey: string) {
1971
+ if (!session || typeof session !== 'object') return
1972
+ roundInjectionBudget.set(session, { roundKey: String(roundKey ?? ''), used: 0 })
1973
+ }
1974
+
1975
+ function roundBudgetOf(session: any) {
1976
+ let budget = roundInjectionBudget.get(session)
1977
+ if (!budget) {
1978
+ budget = { roundKey: '', used: 0 }
1979
+ roundInjectionBudget.set(session, budget)
1980
+ }
1981
+ return budget
1982
+ }
1983
+
1984
+ /** 单条 500 字符上限:超出截断并附按需查询指针(truncate 的 … 计入长度)。 */
1985
+ export function capKeyProgressText(text: string) {
1986
+ if (text.length <= KEY_PROGRESS_SINGLE_LIMIT) return text
1987
+ return truncate(text, KEY_PROGRESS_SINGLE_LIMIT - KEY_PROGRESS_POINTER.length) + KEY_PROGRESS_POINTER
1988
+ }
1989
+
1990
+ /*
1991
+ * C2 禁止清单(前缀逐字来自现有 builder 文案,F2 37/37 分类表 B 类):
1992
+ * 派发/规划心跳、规划/派发预告、专家预估上报、规划失败重试过程通知。
1993
+ * 最终失败仍由 buildDegradedMessage 另行提示,不在此列。
1994
+ */
1995
+ const BANNED_NOTICE_PREFIXES = [
1996
+ '【派发执行中】',
1997
+ '【规划预告】',
1998
+ '【规划进行中】',
1999
+ '【派发预告】',
2000
+ '【dsh-workplan·专家预估上报】',
2001
+ '【自动分解】第 ',
2002
+ ]
2003
+ export function isBannedProgressNotice(text: string) {
2004
+ return BANNED_NOTICE_PREFIXES.some((prefix) => text.startsWith(prefix))
2005
+ }
2006
+
2007
+ /* 信封已迁至 source.durable 的 kind:可见文本由 builder 负责,闸门只做上限。 */
2008
+ const DURABLE_ENVELOPE_KINDS = new Set([
2009
+ 'workplan-update', 'workplan-replan', 'workplan-cancel', 'workplan-result', 'workplan-change',
2010
+ ])
2011
+
2012
+ /*
2013
+ * ============ [2.5.5][T10] 非关键 workplan-update 合并闸(用户 2026-11-14 裁决 A) ============
2014
+ * 现象(用户截图 IMG_0472/IMG_0473):一个 7 子任务的计划跑完,对话里堆了 37 条
2015
+ * 「上下文注入 · workplan-update · 【状态改判】…」卡片;每条都是空可见文本的台账
2016
+ * 事件,模型上下文里没有正文,但每一条都作为独立 user/message 事件落盘、被界面
2017
+ * 逐条渲染成卡片,把对话刷满。
2018
+ *
2019
+ * 治本:这类事件是台账,不是对话。对话里只需要「关键节点」(keyProgress===true,
2020
+ * 由 buildUpdateMessage 写出真实一行文案)。非关键台账事件先进入按 session 的
2021
+ * 有界缓冲,在下列任一时机合并成**一条**汇总消息落盘:
2022
+ * - 下一条可落盘消息到来之前(保序,回放顺序与原逐条追加一致);
2023
+ * - 缓冲静默 PENDING_UPDATE_FLUSH_MS(当前 20s;崩溃前最多丢一个静默窗口的台账,而不是整轮);
2024
+ * - 条数 / 体积达到上限(防止单条消息过大);
2025
+ * - 本轮结算 finishRound 之前。
2026
+ * 回放侧 parseUpdateMessages 把汇总消息里的 updates 数组按序逐条返回,语义与
2027
+ * 逐条落盘完全等价(reconstructFromSession 仍是唯一的应用者)。
2028
+ */
2029
+ export const PENDING_UPDATE_COUNT_LIMIT = 100
2030
+ export const PENDING_UPDATE_SIZE_LIMIT = 200_000
2031
+ const PENDING_UPDATE_FLUSH_MS = 20_000
2032
+
2033
+ interface PendingUpdateBuffer {
2034
+ planId: string
2035
+ updates: any[]
2036
+ size: number
2037
+ dropped: number
2038
+ }
2039
+
2040
+ const pendingUpdateBuffers = new WeakMap<object, PendingUpdateBuffer>()
2041
+ const pendingUpdateTimers = new WeakMap<object, ReturnType<typeof setTimeout>>()
2042
+ const flushingUpdateSessions = new WeakSet<object>()
2043
+
2044
+ function pendingBufferOf(session: any): PendingUpdateBuffer {
2045
+ let buffer = pendingUpdateBuffers.get(session)
2046
+ if (!buffer) {
2047
+ buffer = { planId: '', updates: [], size: 0, dropped: 0 }
2048
+ pendingUpdateBuffers.set(session, buffer)
2049
+ }
2050
+ return buffer
2051
+ }
2052
+
2053
+ /** 缓冲里还有多少条未落盘的台账事件(测试/诊断用)。 */
2054
+ export function pendingWorkplanUpdateCount(session: any) {
2055
+ const buffer = session && typeof session === 'object' ? pendingUpdateBuffers.get(session) : undefined
2056
+ return buffer ? buffer.updates.length : 0
2057
+ }
2058
+
2059
+ function schedulePendingUpdateFlush(session: any) {
2060
+ if (typeof setTimeout !== 'function') return
2061
+ if (pendingUpdateTimers.has(session)) return
2062
+ const timer = setTimeout(() => {
2063
+ pendingUpdateTimers.delete(session)
2064
+ try {
2065
+ flushPendingWorkplanUpdates(session)
2066
+ } catch {
2067
+ /* 定时补发失败不抛:下一次 append / 结算会再试,台账不静默消失。 */
2068
+ }
2069
+ }, PENDING_UPDATE_FLUSH_MS)
2070
+ if (typeof (timer as any)?.unref === 'function') (timer as any).unref()
2071
+ pendingUpdateTimers.set(session, timer)
2072
+ }
2073
+
2074
+ /**
2075
+ * 把一条「空可见文本的 workplan-update」放进缓冲。
2076
+ * @returns true 表示已缓冲(调用方不得再 append);false 表示不是可缓冲事件。
2077
+ */
2078
+ function tryBufferWorkplanUpdate(session: any, message: any) {
2079
+ const durable = message?.source?.durable
2080
+ if (!isRecord(durable) || durable.kind !== 'workplan-update') return false
2081
+ if (Array.isArray(durable.updates)) return false
2082
+ if (messageText(message).trim() !== '') return false
2083
+ const buffer = pendingBufferOf(session)
2084
+ if (!buffer.planId && typeof durable.planId === 'string') buffer.planId = durable.planId
2085
+ buffer.updates.push(durable)
2086
+ try {
2087
+ buffer.size += JSON.stringify(durable).length
2088
+ } catch {
2089
+ buffer.size += 512
2090
+ }
2091
+ while (buffer.updates.length > PENDING_UPDATE_COUNT_LIMIT) {
2092
+ buffer.updates.shift()
2093
+ buffer.dropped += 1
2094
+ }
2095
+ if (buffer.updates.length > 0 && (buffer.updates.length >= PENDING_UPDATE_COUNT_LIMIT || buffer.size >= PENDING_UPDATE_SIZE_LIMIT)) {
2096
+ flushPendingWorkplanUpdates(session)
2097
+ } else {
2098
+ schedulePendingUpdateFlush(session)
2099
+ }
2100
+ return true
2101
+ }
2102
+
2103
+ /**
2104
+ * 把缓冲的台账事件合并成一条汇总 user/message 落盘(保序)。
2105
+ * 无缓冲时返回 undefined;内部经 appendUserMessage,因此同样受单条/整轮上限约束。
2106
+ */
2107
+ export function flushPendingWorkplanUpdates(session: any) {
2108
+ if (!session || typeof session !== 'object') return undefined
2109
+ const buffer = pendingUpdateBuffers.get(session)
2110
+ if (!buffer || buffer.updates.length === 0) return undefined
2111
+ const updates = buffer.updates
2112
+ const planId = buffer.planId || (typeof updates[updates.length - 1]?.planId === 'string' ? updates[updates.length - 1].planId : '')
2113
+ const tail = updates
2114
+ .slice(-6)
2115
+ .map((item: any) => `${String(item?.subtaskId ?? '计划级')}→${String(item?.status ?? '更新')}`)
2116
+ .join(';')
2117
+ const more = updates.length > 6 ? `;另 ${updates.length - 6} 条` : ''
2118
+ const dropped = buffer.dropped > 0 ? `;早期 ${buffer.dropped} 条已丢弃` : ''
2119
+ const text = capKeyProgressText(`【进度归档】${updates.length} 条台账更新已合并(${tail}${more}${dropped})`)
2120
+ const summary = truncate(`【进度归档】${updates.length} 条台账更新已合并落盘`, 120)
2121
+ const message = makeUserMessage(text, {
2122
+ kind: 'workplan-update',
2123
+ form: 'notice',
2124
+ summary,
2125
+ durable: { kind: 'workplan-update', version: PLAN_VERSION, planId, updates, merged: true, at: Date.now() },
2126
+ })
2127
+ if (userMessageShapeProblem(message) !== null) return undefined
2128
+ flushingUpdateSessions.add(session)
2129
+ try {
2130
+ const appended = appendUserMessage(session, message)
2131
+ /* 只有真正落盘才清空缓冲:append 抛错时下次 flush 重试,台账不静默消失。 */
2132
+ if (pendingUpdateBuffers.get(session) === buffer) pendingUpdateBuffers.delete(session)
2133
+ const timer = pendingUpdateTimers.get(session)
2134
+ if (timer) {
2135
+ clearTimeout(timer as any)
2136
+ pendingUpdateTimers.delete(session)
2137
+ }
2138
+ return appended
2139
+ } finally {
2140
+ flushingUpdateSessions.delete(session)
2141
+ }
2142
+ }
2143
+
2144
+ export function appendUserMessage(session: any, payload: any, source?: any, opts?: { deferUntilHead?: boolean; allowBanned?: boolean }) {
1574
2145
  if (!session || typeof session.append !== 'function') return undefined
1575
2146
  let message = payload
1576
2147
  if (typeof payload === 'string') {
@@ -1579,6 +2150,70 @@ export function appendUserMessage(session: any, payload: any, source?: any) {
1579
2150
  }
1580
2151
  const problem = userMessageShapeProblem(message)
1581
2152
  if (problem !== null) throw new Error(`dsh-workplan: refusing to append malformed user/message (${problem})`)
2153
+ /*
2154
+ * [2.5.5][T10] 合并闸(在收敛闸门之前):
2155
+ * - 非关键台账(空可见文本的 workplan-update)→ 进缓冲,本次不落盘;
2156
+ * - 其它任何消息落盘前,先把缓冲合并成一条汇总消息(保序),再落本条。
2157
+ * 关键节点(keyProgress===true,文本非空)不缓冲、文案不变。
2158
+ */
2159
+ if (!flushingUpdateSessions.has(session)) {
2160
+ if (tryBufferWorkplanUpdate(session, message)) return undefined
2161
+ try {
2162
+ flushPendingWorkplanUpdates(session)
2163
+ } catch {
2164
+ /* 汇总落盘失败不得拖垮本条关键消息:缓冲保留,下一次落盘/结算再试。 */
2165
+ }
2166
+ }
2167
+ /*
2168
+ * [T7] 收敛闸门(形状校验之后、头前暂存之前——暂存队列绕过闸门直接
2169
+ * append,所以过滤与计数必须在这里完成,flushPreHeadNotices 补写的已是
2170
+ * 裁剪后消息)。durable 信封类(update/replan/cancel/result/change)的
2171
+ * 可见文本由 builder 裁剪;空文本 durable 事件仍必须 append(回放台账)。
2172
+ */
2173
+ const noticeKind = String(message?.source?.kind ?? '')
2174
+ const originalText = messageText(message)
2175
+ const durableEnvelope = DURABLE_ENVELOPE_KINDS.has(noticeKind)
2176
+ // C2:过程通知整条不注入。allowBanned 仅供「用户显式要求必须送达」的
2177
+ // 必需通知(如 2.3.0 用户要求 1 的专家预估上报)走专用豁免;禁用清单本身
2178
+ // 保持不变,isBannedProgressNotice 的语义不变。
2179
+ if (!opts?.allowBanned && !durableEnvelope && originalText && isBannedProgressNotice(originalText)) return undefined
2180
+ // 计划定义(PLAN_MARKER)与用户变更原文(workplan-change)豁免上限。
2181
+ const exemptFromCap = noticeKind === 'workplan-change' || originalText.includes(PLAN_MARKER_BEGIN)
2182
+ if (originalText.length > 0 && !exemptFromCap) {
2183
+ const budget = roundBudgetOf(session)
2184
+ let capped: string
2185
+ if (budget.used >= KEY_PROGRESS_ROUND_LIMIT) {
2186
+ // 极简一行:首行(关键进度行以 ID+状态开头)+按需指针;不静默丢失。
2187
+ capped = truncate(originalText.split('\n')[0] ?? '', 80) + KEY_PROGRESS_BUDGET_POINTER
2188
+ } else {
2189
+ capped = capKeyProgressText(originalText)
2190
+ }
2191
+ budget.used += capped.length
2192
+ if (capped !== originalText) message = { ...message, content: [{ type: 'text', text: capped }] }
2193
+ }
2194
+ /*
2195
+ * [2.5.5][治本·前置闸] 受保护系统头(首个 system/message)落地前的 surface
2196
+ * 写入一律暂存、头后按序补发。覆盖两类来源:① 调用方显式 opts.deferUntilHead
2197
+ * (规划预告/心跳/重试回报);② pre-step 规划/自动派发窗口(enterPreHeadWindow
2198
+ * 标记,maybePlan 入口设置)——根因实证(session-1513aa1d / session-6e26e9e5
2199
+ * 离线回放):派发崩溃中断通知/受阻通知/快速结算消息都落在该窗口(seq7-13
2200
+ * 先于 system/message seq15),重启后读取端 assertReleasedV4Relationships 抛
2201
+ * "system/message requires a protected first surface head",整份历史被判
2202
+ * corrupt、会话无法继续。真实宿主里工具调用/结算必在首 step 系统头之后,
2203
+ * 窗口外写入立即执行(单元桩同此契约,零回归);opts.deferUntilHead === false
2204
+ * 为显式逃生门。schedulePreHeadFlush 保险丝:头落地后即使没有下一次写入也
2205
+ * 自动补发,进度全程可见且不丢内容。
2206
+ */
2207
+ const deferRequested = opts?.deferUntilHead !== false
2208
+ && (opts?.deferUntilHead === true || preHeadWindowSessions.has(session))
2209
+ if (deferRequested && !surfaceHeadExists(session)) {
2210
+ const queue = preHeadNoticeQueue.get(session) ?? []
2211
+ queue.push(message)
2212
+ preHeadNoticeQueue.set(session, queue)
2213
+ schedulePreHeadFlush(session)
2214
+ return undefined
2215
+ }
2216
+ flushPreHeadNotices(session)
1582
2217
  return session.append('user/message', message, { surfaceOp: 'append' })
1583
2218
  }
1584
2219
 
@@ -1655,6 +2290,101 @@ export function createPlannerProgressReporter(options: {
1655
2290
  }
1656
2291
  }
1657
2292
 
2293
+ /*
2294
+ * [2.5.2] 规划期间心跳(用户 2026-11-11 报告:本会话 turn 1 规划 12.5 分钟
2295
+ * 全程零会话输出,用户以为死机并手动中断,turn/end reason=interrupted)。
2296
+ *
2297
+ * 根因:runPlanner 的失败重试回报器(createPlannerProgressReporter)只在
2298
+ * 「失败且会退避重试」时发通知;一次**持续流式输出但很慢**的尝试(推理
2299
+ * chunk 不断重置 idle 窗口,最长可达绝对上限 900s)既不失败也不触发 idle,
2300
+ * 于是【规划预告】之后整段静默,用户无法区分「正在生成」与「卡死」。
2301
+ *
2302
+ * 心跳与失败重试正交:只要规划还在跑,就按固定间隔在会话里发一条「仍在
2303
+ * 生成、已用时多久、不是卡死」的可见通知。纯函数 + 依赖注入工厂,便于脱离
2304
+ * 宿主运行态做单元回归;写入仍走唯一合规写入器 appendUserMessage
2305
+ * (user/message,surfaceOp:'append',形状校验),不新增任何事件类型、不
2306
+ * 触碰 system/message,故不会引入会话日志损坏;调用方在 finally 里 stop,
2307
+ * 绝不残留定时器(吸取 2.2.8/2.2.9 计时器收束教训)。
2308
+ */
2309
+ export function planningHeartbeatIntervalMs(value: any) {
2310
+ const ms = Number(value)
2311
+ return Number.isFinite(ms) && ms >= 5000 ? Math.round(ms) : 45000
2312
+ }
2313
+
2314
+ export function buildPlanningHeartbeat(elapsedMs: any, attempt: any, maxAttempts: any) {
2315
+ const totalSecs = Math.max(0, Math.round(Number(elapsedMs) / 1000))
2316
+ const mins = Math.floor(totalSecs / 60)
2317
+ const secs = totalSecs % 60
2318
+ const elapsed = mins > 0 ? `${mins} 分 ${secs} 秒` : `${secs} 秒`
2319
+ const total = Math.max(1, Number(maxAttempts) || 1)
2320
+ const current = Math.min(total, Math.max(1, Number(attempt) || 1))
2321
+ const attemptPart = current > 1 ? `(第 ${current}/${total} 次尝试)` : ''
2322
+ return `【规划进行中】任务分解仍在生成,已用时 ${elapsed}${attemptPart},正在等待模型返回,不是卡死。完成后会立即显示【任务分解】;若失败会自动重试并另行提示。(进度心跳,仅供参考)`
2323
+ }
2324
+
2325
+ /**
2326
+ * [2.5.2][stall-fix] 派发执行期进度心跳文案(用户报告「提交任务后长时间无反应」):
2327
+ * 规划心跳只覆盖 runPlanner;派发后的执行轮次同样可能长达十几分钟,旧实现
2328
+ * 期间零会话输出,用户无法区分「在跑」与「卡死」。执行心跳按固定间隔报告
2329
+ * 已用时与完成进度,与规划心跳同一收束纪律(finally stop + 保险丝)。
2330
+ */
2331
+ export function buildDispatchHeartbeat(elapsedMs: any, done: any, total: any, running: any) {
2332
+ const totalSecs = Math.max(0, Math.round(Number(elapsedMs) / 1000))
2333
+ const mins = Math.floor(totalSecs / 60)
2334
+ const secs = totalSecs % 60
2335
+ const elapsed = mins > 0 ? `${mins} 分 ${secs} 秒` : `${secs} 秒`
2336
+ const doneN = Math.max(0, Number(done) || 0)
2337
+ const totalN = Math.max(doneN, Number(total) || 0)
2338
+ const runningN = Math.max(0, Number(running) || 0)
2339
+ return `【派发执行中】已用时 ${elapsed},完成 ${doneN}/${totalN}${runningN > 0 ? `,${runningN} 个子任务执行中` : ''},不是卡死。结果会在本轮结束时自动写入;受阻会即时提示。(进度心跳,仅供参考)`
2340
+ }
2341
+
2342
+ export function createPlanningHeartbeat(options: {
2343
+ signal?: any
2344
+ appendNotice: (text: string) => void
2345
+ intervalMs?: number
2346
+ startedAt: number
2347
+ getAttempt?: () => number
2348
+ maxAttempts: number
2349
+ maxNotices?: number
2350
+ now?: () => number
2351
+ setTimer?: (fn: () => void, ms: number) => any
2352
+ clearTimer?: (handle: any) => void
2353
+ /** [2.5.2][stall-fix] 自定义文案(执行心跳用);缺省=规划心跳文案。 */
2354
+ buildMessage?: (elapsedMs: number) => string
2355
+ }) {
2356
+ const interval = planningHeartbeatIntervalMs(options.intervalMs)
2357
+ // 上限只是防失控的保险丝;真正的收束是调用方 finally 里的 stop()。
2358
+ const maxNotices = Math.max(1, Number(options.maxNotices) || 40)
2359
+ const now = options.now ?? (() => Date.now())
2360
+ const setTimer = options.setTimer ?? ((fn: () => void, ms: number) => setInterval(fn, ms))
2361
+ const clearTimer = options.clearTimer ?? ((handle: any) => clearInterval(handle))
2362
+ let handle: any = null
2363
+ let notices = 0
2364
+ const stop = () => {
2365
+ if (handle !== null) {
2366
+ clearTimer(handle)
2367
+ handle = null
2368
+ }
2369
+ }
2370
+ const tick = () => {
2371
+ if (options.signal?.aborted) { stop(); return }
2372
+ if (notices >= maxNotices) { stop(); return }
2373
+ notices += 1
2374
+ const elapsedMs = now() - options.startedAt
2375
+ const text = options.buildMessage
2376
+ ? options.buildMessage(elapsedMs)
2377
+ : buildPlanningHeartbeat(elapsedMs, options.getAttempt ? options.getAttempt() : 1, options.maxAttempts)
2378
+ options.appendNotice(text)
2379
+ }
2380
+ const start = () => {
2381
+ if (handle !== null) return
2382
+ if (options.signal?.aborted) return
2383
+ handle = setTimer(tick, interval)
2384
+ }
2385
+ return { start, stop }
2386
+ }
2387
+
1658
2388
  export function buildPlanSummary(plan: any) {
1659
2389
  const total = flattenSubtasks(plan).length
1660
2390
  const primary = plan.contradictions.primary.statement
@@ -1686,6 +2416,60 @@ export function estimatePlanMinutes(plan: any, fallbackMinutes = 15, concurrency
1686
2416
  return Math.max(waves * maxEstimate, Math.ceil(totalEstimate / Math.max(1, concurrency)))
1687
2417
  }
1688
2418
 
2419
+ /*
2420
+ * [2.3.10][T2] 用户要求1:分配前会话内耗时预告(P1/P2 文案纯函数)。
2421
+ * 只生成追加式 notice 文案,不写任何 schema、不改任何工具参数/输出;措辞遵守
2422
+ * O-5b 契约(见 buildBudgetWarning advisory):凡预估必带「仅供参考,非承诺」。
2423
+ * - 规划预估口径:单次规划窗口是超时安全兜底而非典型时长,取窗口一半作典型
2424
+ * 完成时间、向上取整、至少 1 分钟;失败重试由既有进度回报器另行提示。
2425
+ * - 派发预估口径:复用 estimatePlanMinutes 的下界估算(estimateMinutes+并发度)。
2426
+ */
2427
+ export function planningEstimateMinutes(windowMs: any) {
2428
+ const ms = Number(windowMs)
2429
+ const window = Number.isFinite(ms) && ms > 0 ? ms : 300000
2430
+ return Math.max(1, Math.ceil(window / 60000 / 2))
2431
+ }
2432
+
2433
+ export function buildPlanningPreAnnouncement(windowMs: any, maxAttempts: any) {
2434
+ const ms = Number(windowMs)
2435
+ const window = Number.isFinite(ms) && ms > 0 ? ms : 300000
2436
+ const minutes = planningEstimateMinutes(window)
2437
+ const windowMinutes = Math.max(1, Math.round(window / 60000))
2438
+ const attempts = Math.max(1, Number(maxAttempts) || 1)
2439
+ return `【规划预告】正在生成本次任务分解:规划过程预估约 ${minutes} 分钟(口径:按单次规划窗口 ${windowMinutes} 分钟的典型完成时间估算;最多尝试 ${attempts} 次,失败重试会另行提示。预估仅供参考,非承诺)。`
2440
+ }
2441
+
2442
+ export function buildDispatchPreAnnouncement(plan: any) {
2443
+ const total = flattenSubtasks(plan).length
2444
+ if (total === 0) return ''
2445
+ const minutes = Math.max(1, estimatePlanMinutes(plan))
2446
+ return `【派发预告】本次分配 ${total} 个子任务,预计执行约 ${minutes} 分钟(口径:按各子任务 estimateMinutes 与并发度的下界估算。预估仅供参考,非承诺;实际时长由执行专家开工预告协商决定)。`
2447
+ }
2448
+
2449
+ /**
2450
+ * [2.5.0][自配档] phase-0 任务书(负责人):唯一职责=评估复杂度+提交自配。
2451
+ * 平台强制两段式的第一段;phase-1 由 runSubtaskAttempt 在登记后以自配档接续。
2452
+ */
2453
+ export function buildPhaseZeroLeaderPrompt(input: { subtaskId?: string; title?: string; objective?: string; departmentLabel?: string }) {
2454
+ return [
2455
+ `你是「${input.departmentLabel ?? '部门'}」部门的执行负责人,当前处于 phase-0(先配置后开工,low 档启动)。`,
2456
+ `你的子任务:${input.subtaskId ?? ''} ${input.title ?? ''}`,
2457
+ `任务目标:${input.objective ?? '(未记录)'}`,
2458
+ '本阶段唯一职责:全面评估你接到任务的复杂度,然后调用 dsh_workplan_delegate(action="review") 提交两轮深度思考产物(第一轮任务深研 + 第二轮方法流程步骤 + 依据 approachBasis)与分工表,并在 consolidation.taskReasoningEffort 里配置你自己的整体推理等级(轻度=low;qwen 中等=medium、非 qwen 中等=high;qwen 非常复杂=xhigh、非 qwen 非常复杂=max)。若评估为 low(轻度)或未配置:禁止下派——不要提交分工表,改经 dsh_workplan_delegate(action="direct") 登记两轮思考产物(deepThink,40/40/20 字,可选 reasoningEffort="low"),平台以 low 档接续你亲自执行。',
2459
+ '不要执行任务本身,不要派发下级(review 登记前 dispatch 会被硬门禁拒绝)。提交 review 后结束本回合;平台会立即以你的自配档接续本会话进入 phase-1(正式分配流程)。',
2460
+ ].join('\n')
2461
+ }
2462
+
2463
+ /** [2.5.0][自配档] phase-0→phase-1 接续块(负责人):携带 phase-0 产物+继续勿重做。 */
2464
+ export function buildPhaseZeroContinuationHint(effort: string, phaseZeroOutput: string, lowDirect = false) {
2465
+ // [2.5.5][T3] W11:low 直执行(effortOverride='low' 且分工表为空)时指路 direct 亲自执行;
2466
+ // 缺省 false,既有调用零影响(调用点派生量由 runtime 传入)。
2467
+ const nextStep = lowDirect
2468
+ ? 'low 任务亲自执行:禁止 review/dispatch(low 禁派闸);两轮思考产物未登记先经 action="direct" 补齐,然后直接执行任务'
2469
+ : '直接进入正式分配流程(review 已登记则 dispatch,未登记先补齐 review)'
2470
+ return `【phase-0→phase-1 接续——继续勿重做】你已在 phase-0 完成复杂度评估并配置整体推理等级 \`${effort}\`(effortOverride 已登记,重试/续跑全程生效)。平台已按你的自配档接续本会话;phase-0 输出:${truncate(String(phaseZeroOutput ?? ''), 600) || '(无)'}。${nextStep},不要重新评估复杂度,不要重做 phase-0 已完成的工作。`
2471
+ }
2472
+
1689
2473
  export function buildBudgetWarning(plan: any, totalBudgetMinutes = 0, maxResumes = MAX_PLAN_RESUMES) {
1690
2474
  const minutes = estimatePlanMinutes(plan)
1691
2475
  const rawBudget = Number(totalBudgetMinutes)
@@ -1699,7 +2483,7 @@ export function buildBudgetWarning(plan: any, totalBudgetMinutes = 0, maxResumes
1699
2483
  * 把预估标注为仅供参考/非承诺」:凡 buildBudgetWarning 有输出必带该标注,
1700
2484
  * 计划消息经 warning 路径同享,不再按超预算与否吞掉)。
1701
2485
  */
1702
- const advisory = '(子任务 estimateMinutes 预估仅供参考,非承诺;实际时长协商决定:由执行专家开工预告协商,不设固定完成时间。)'
2486
+ const advisory = '(子任务 estimateMinutes 预估仅供参考,非承诺;判据层完成目标 ≤10 分钟,默认必须达成、超出须用户明确批准并留痕;运行层安全兜底由执行专家开工预告协商决定,不设固定交付期限、不构成对外承诺。)'
1703
2487
  // [2.2.5] 0 = 本轮不设固定总预算:只保留“预估仅供参考”的标注,不再输出
1704
2488
  // “超过本轮预算/需要 N 轮”的提示,避免与“不强制限制”的目标矛盾。
1705
2489
  if (budget === 0 || minutes <= budget) return advisory
@@ -1710,7 +2494,7 @@ export function buildBudgetWarning(plan: any, totalBudgetMinutes = 0, maxResumes
1710
2494
  + `预计需要约 ${rounds} 轮(续跑额度 ${maxResumes} 次)。`,
1711
2495
  advisory,
1712
2496
  '建议:拆成多轮,或减少同时进行的子任务。',
1713
- ...(missing ? ['(部分子任务缺少 estimateMinutes,已按每项 15 分钟默认值估算。)'] : []),
2497
+ ...(missing ? ['(部分子任务缺少 estimateMinutes,已按运行层预算默认值每项 15 分钟估算。)'] : []),
1714
2498
  ].join('\n')
1715
2499
  }
1716
2500
 
@@ -1730,8 +2514,22 @@ export function buildPlanMessage(plan: any, options: any = {}) {
1730
2514
  options.totalBudgetMinutes ?? 0,
1731
2515
  options.maxResumes ?? MAX_PLAN_RESUMES,
1732
2516
  )
2517
+ /*
2518
+ * [3.0.0][用户要求 1] 用户刚才输入的任务内容必须能在会话内看到。
2519
+ *
2520
+ * 事故现象(用户 2026-11-14):在等待任务分配期间切换会话、再切回来,
2521
+ * 一开始输入的任务内容在会话里看不到了——用户失去对自己需求的可见性。
2522
+ * 计划消息是持久化的会话事件(plan 卡片 + 这条 user/message 都落盘),
2523
+ * 因此把任务原文逐字带进本条消息的可见文本:无论渲染层把首条用户消息
2524
+ * 如何处理,任务内容都还在会话里、且与 taskAnchor 同一来源、同一哈希。
2525
+ */
2526
+ const taskAnchorText = typeof plan?.taskAnchor?.text === 'string' ? plan.taskAnchor.text.trim() : ''
2527
+ const taskTextBlock = taskAnchorText === ''
2528
+ ? []
2529
+ : ['用户刚才输入的任务原文(只读锚点,与你最初的输入逐字一致):', truncate(taskAnchorText, 4000)]
1733
2530
  const text = [
1734
2531
  summary,
2532
+ ...(taskTextBlock.length > 0 ? ['', ...taskTextBlock] : []),
1735
2533
  /*
1736
2534
  * [2.2.0][T3/O-5b/E2] 计划消息中的预估一律标注「非承诺」(方案 §1⑤ O-5b:
1737
2535
  * 「预估一律标注『仅供参考,实际时长由执行专家预告协商』」;验收 E2)。
@@ -1997,6 +2795,13 @@ export function buildResultMessage(result: any) {
1997
2795
  if (missingArtifacts.length > 0) {
1998
2796
  review.push(`- 声明产物缺失:${missingArtifacts.slice(0, 10).join(';')}`)
1999
2797
  }
2798
+ /*
2799
+ * [T9] review[] 明细随 durable 信封落盘(C2「按需可查」):可见正文收敛为
2800
+ * 一行关键进度,但未验证/自检失败/旧格式/缺失产物/待指示等证据核对明细
2801
+ * 不得「构造后无人使用」成为死代码;parseResultMessage 优先读 durable,
2802
+ * 主 Agent 与回放可按需取回逐项内容。
2803
+ */
2804
+ const envelope = review.length > 0 ? { ...payload, review } : payload
2000
2805
  /*
2001
2806
  * [1.8.7] 未完成时不能再命令「给出最终答复」。
2002
2807
  *
@@ -2035,41 +2840,52 @@ export function buildResultMessage(result: any) {
2035
2840
  : paused
2036
2841
  ? `本轮执行预算用尽,剩余 ${Number(result.stats?.pending ?? 0)} 项未完成(不是失败、未计入续跑额度):再次调用 dsh_workplan_dispatch 即可从剩下的步骤继续,已完成的不重跑。`
2037
2842
  : `剩余 ${remaining} 项子任务还没有完成:再次调用 dsh_workplan_dispatch 即可继续跑,已完成的不重跑。`
2038
- const lines = [
2039
- summary,
2040
- '',
2041
- '各部门子任务结果如下,请主 Agent:',
2042
- '1. 核对每个完成项的证据与验收标准;',
2043
- '2. 处理受阻项,必要时向用户确认;',
2044
- ...(cancelled
2045
- ? [
2046
- `3. 【已取消但未完成,禁止交付】计划只完成 ${doneCount}/${totalCount},剩余 ${remaining} 项(取消只停止执行,不等于完成):不要调用 present,不要写“已完成/最终版/已交付”,不要给出收尾性最终答复,不要声称未验证的完成。`,
2047
- '4. 不要再调用 dsh_workplan_dispatch(计划已取消,不会启动任何部门 Agent)。如需继续这项工作,请向用户确认后重新生成计划。答复开头必须写「未完成:剩余 N 项与原因」。',
2048
- ]
2049
- : incomplete
2050
- ? [
2051
- `3. 【未完成,禁止交付】计划只完成 ${doneCount}/${totalCount},还有 ${remaining} 项没做完:不要调用 present 交付当前产物,不要写“已完成/最终版/已交付”,也不要给出收尾性最终答复,不要声称未验证的完成。`,
2052
- `4. ${recovery}`,
2053
- ]
2054
- : evidenceBlocked
2055
- ? [
2056
- `3. 【证据未通过,禁止交付】计划 ${doneCount}/${totalCount} 虽已全部 done,但以下证据缺口未通过:${shownBlockers}${deliveryBlockers.length > 8 ? '…' : ''}。不要调用 present,不要写“已完成/最终版/已交付”,不要给出收尾性最终答复,不要声称未验证的完成。`,
2057
- '4. 先用 dsh_workplan_update 为这些子任务补齐 verification=\'structured\' 与 acceptance(每项 result=\'pass\',并附证据),或把对应子任务改回 blocked 并写明原因;缺口补齐、deliveryReady 变为 true 之后 present 才会放行。',
2058
- ]
2059
- : ['3. 给出最终答复,不要声称未验证的完成。']),
2060
- ...(review.length > 0 ? ['', '验收核对:', ...review] : []),
2061
- ...(needs.length > 0
2062
- ? ['', '跨部门待转达(子 Agent 提出的需求;用 dsh_workplan_handoff 逐条 assign/resolve/close,未处置会拦住交付):', ...needs.slice(0, 10).map((line: string) => `- ${line}`)]
2063
- : []),
2064
- '',
2065
- RESULT_MARKER_BEGIN,
2066
- JSON.stringify(payload),
2067
- RESULT_MARKER_END,
2068
- ]
2069
- return makeUserMessage(lines.join('\n'), {
2843
+ /*
2844
+ * [T7] 可见文本收敛(C1b/C3)+信封载体迁移(选项 A):轮结果只注入一行
2845
+ * 计划级关键进度——完成 X/Y、deliveryReady、剩余项 ID 与原因、待指示、
2846
+ * 下一步;全量 statuses/证据核对/跨部门需求明细随 source.durable 落盘,
2847
+ * 主 Agent 用 dsh_workplan_status/dsh_workplan_handoff 按需获取。
2848
+ * 偏离留痕:设计书原定「非终态过程轮不注入摘要」,实现改为每轮一行——
2849
+ * 轮结束是主 Agent 续跑/交付决策的触发事件(async 派发唯一通知源),
2850
+ * 整条置空会使在途编排停摆(违反 C4 在途行为不变);一行 ≤500 字符,
2851
+ * 体积相对旧版(可达数千字符)仍收敛 >90%。
2852
+ */
2853
+ const remainingRows = statuses.filter((item: any) => item?.status !== 'done')
2854
+ const remainingIds = remainingRows.map((item: any) => String(item?.subtaskId ?? '')).filter((id: string) => id !== '')
2855
+ const firstReason = truncate(String(remainingRows[0]?.error ?? remainingRows[0]?.question ?? remainingRows[0]?.summary ?? '').replace(/\s+/g, ' ').trim(), 80)
2856
+ const nextAction = cancelled
2857
+ ? '已取消:禁止交付、不再派发'
2858
+ : (!incomplete && readiness?.ready === true)
2859
+ ? '全部完成且可交付:核对证据后 present'
2860
+ : evidenceBlocked
2861
+ ? `证据未通过(缺口 ${deliveryBlockers.length} 处):用 dsh_workplan_update 补齐后再交付`
2862
+ : escalations.length > 0
2863
+ ? '先答复待指示项(instruct)再续跑'
2864
+ : '再次 dsh_workplan_dispatch 续跑(已完成不重跑)'
2865
+ const keyParts = [summary.replace(/^【部门执行结果】/, '【关键进度·计划级】')]
2866
+ keyParts.push(`deliveryReady=${readiness ? String(readiness.ready) : '未知'}`)
2867
+ if (remainingIds.length > 0) {
2868
+ keyParts.push(`剩余 ${remainingIds.length} 项:${remainingIds.slice(0, 6).join('、')}${remainingIds.length > 6 ? '…' : ''}${firstReason ? `(首个原因:${firstReason})` : ''}`)
2869
+ }
2870
+ if (escalations.length > 0) keyParts.push(`待指示:${escalationIds}(先 instruct 答复)`)
2871
+ if (needs.length > 0) keyParts.push(`跨部门需求 ${needs.length} 条待处置(dsh_workplan_handoff list)`)
2872
+ /*
2873
+ * [T9] 旧多行正文里的两条决策必需信息必须在「一行关键进度」里保活:
2874
+ * ①未就绪时显式禁止 present(不能只靠回合收尾 steer:结果消息可能是模型
2875
+ * 当轮唯一读到的通知);②受阻/暂停/未完成时披露续跑额度与恢复指引
2876
+ * (旧正文的「剩余续跑额度 N 次」「不会再自动重跑→直接接手」不得丢失)。
2877
+ * 取消是终态,不附恢复指引(否则等于教模型对已取消计划再次派发)。
2878
+ */
2879
+ const notDeliverable = cancelled || incomplete || (readiness !== null && readiness.ready === false)
2880
+ if (notDeliverable) keyParts.push('禁止交付:不要调用 present')
2881
+ if (!cancelled && (incomplete || blocked > 0 || paused)) keyParts.push(`恢复指引:${truncate(recovery, 200)}`)
2882
+ keyParts.push(`下一步:${nextAction}`)
2883
+ const keyText = capKeyProgressText(keyParts.join('|'))
2884
+ return makeUserMessage(keyText, {
2070
2885
  kind: 'workplan-result',
2071
2886
  form: 'notice',
2072
2887
  summary,
2888
+ durable: envelope,
2073
2889
  })
2074
2890
  }
2075
2891
 
@@ -2190,6 +3006,9 @@ export function parseWorkplanMessage(message: any) {
2190
3006
  }
2191
3007
 
2192
3008
  export function parseResultMessage(message: any) {
3009
+ /* [T7] 先读元数据信封(source.durable,选项 A),回退旧文本标记。 */
3010
+ const durable = message?.source?.durable
3011
+ if (isRecord(durable) && durable.kind === 'workplan-result') return durable
2193
3012
  const body = extractBetween(messageText(message), RESULT_MARKER_BEGIN, RESULT_MARKER_END)
2194
3013
  if (!body) return null
2195
3014
  try {
@@ -2229,28 +3048,17 @@ export function buildCancelMessage(planId: any, reason: any = '用户取消', te
2229
3048
  reason: String(reason || '用户取消'),
2230
3049
  cancelledAt: Date.now(),
2231
3050
  }
2232
- const lines = [
2233
- summary,
2234
- '',
2235
- '这次任务分解已取消。取消只停止后续执行,不会把未完成项标成完成;已完成项保留原记录。',
2236
- /*
2237
- * [1.8.13] Cancel is not a delivery permit. The old text stopped at "不会
2238
- * 标成完成" and never told the model what that means for the reply, so the
2239
- * T5-C snapshot could cancel 1/3 and then present. The same readiness
2240
- * predicate now rejects that present, and this message states the output
2241
- * contract so the model does not try.
2242
- */
2243
- '取消不等于完成:如仍有未完成项或证据缺口,不要调用 present,不要写“已完成/最终版/已交付”;',
2244
- '答复开头必须写「未完成:剩余 N 项(列出 ID)与原因」。',
2245
- '',
2246
- CANCEL_MARKER_BEGIN,
2247
- JSON.stringify(payload),
2248
- CANCEL_MARKER_END,
2249
- ]
2250
- return makeUserMessage(lines.join('\n'), {
3051
+ /*
3052
+ * [T7] 可见文本收敛+信封迁移(选项 A):取消是计划级终态事件(C1b),
3053
+ * 保留一行关键进度与「取消≠完成」输出契约;全量信封随 source.durable
3054
+ * 落盘,parseCancelMessage 先读元数据回退旧文本标记(旧消息零迁移)。
3055
+ */
3056
+ const keyText = capKeyProgressText(`${summary}|取消≠完成:未完成项不得交付、不得声称完成;不要调用 present;答复开头须写「未完成:剩余 N 项(列出 ID)与原因」(按需:dsh_workplan_status)`)
3057
+ return makeUserMessage(keyText, {
2251
3058
  kind: 'workplan-cancel',
2252
3059
  form: 'notice',
2253
3060
  summary,
3061
+ durable: payload,
2254
3062
  })
2255
3063
  }
2256
3064
 
@@ -2290,25 +3098,20 @@ function buildSupersededMessage(planId: any, reason: any, terminal: any) {
2290
3098
  supersededAt,
2291
3099
  supersededBy: by,
2292
3100
  }
2293
- const lines = [
2294
- summary,
2295
- '',
2296
- '这次任务分解的责任已转移给一个可验证的承接计划。被取代不等于完成:',
2297
- '原计划的记录与计数原样保留,未完成项永远不会因为这次转移而变成完成。',
2298
- '交付时只能使用承接计划通过交付就绪检查的产物;原计划不作为完成证据。',
2299
- '',
2300
- CANCEL_MARKER_BEGIN,
2301
- JSON.stringify(payload),
2302
- CANCEL_MARKER_END,
2303
- ]
2304
- return makeUserMessage(lines.join('\n'), {
3101
+ /* [T7] 可见文本收敛+信封迁移(选项 A):取代是计划级终态事件(C1b)。 */
3102
+ const keyText = capKeyProgressText(`${summary}|被取代≠完成:原计划记录原样保留,未完成项不会因转移变成完成;交付只用承接计划通过就绪检查的产物(按需:dsh_workplan_status)`)
3103
+ return makeUserMessage(keyText, {
2305
3104
  kind: 'workplan-cancel',
2306
3105
  form: 'notice',
2307
3106
  summary,
3107
+ durable: payload,
2308
3108
  })
2309
3109
  }
2310
3110
 
2311
3111
  export function parseCancelMessage(message: any) {
3112
+ /* [T7] 先读元数据信封(source.durable,选项 A),回退旧文本标记。 */
3113
+ const durable = message?.source?.durable
3114
+ if (isRecord(durable) && durable.kind === 'workplan-cancel') return durable
2312
3115
  const body = extractBetween(messageText(message), CANCEL_MARKER_BEGIN, CANCEL_MARKER_END)
2313
3116
  if (!body) return null
2314
3117
  try {
@@ -2339,34 +3142,14 @@ export function normaliseCriterion(value: any) {
2339
3142
  /**
2340
3143
  * [2.0.4] 两条验收描述的相似度(0–1)。
2341
3144
  *
2342
- * 用字符二元组 Dice 系数而不是编辑距离:中文短句里「逐项」「一致性」这类
3145
+ * [3.0.0] 算法实现统一以 v3-contract 的 diceSimilarity 为单一真源
3146
+ * (字符二元组 Dice 系数而不是编辑距离:中文短句里「逐项」「一致性」这类
2343
3147
  * 词被增删时,二元组重合度比字符级编辑距离更接近人的判断,也不需要引入
2344
- * 任何依赖。空串与单字返回 0,交给调用方的长度门槛处理。
3148
+ * 任何依赖);本函数保留为兼容别名,调用方阈值语义不变(此处 ≥0.7)。
2345
3149
  */
2346
3150
  export function criterionSimilarity(a: string, b: string) {
2347
3151
  if (!a || !b) return 0
2348
- if (a === b) return 1
2349
- const grams = (text: string) => {
2350
- const chars = Array.from(text)
2351
- const out = new Map<string, number>()
2352
- for (let i = 0; i + 1 < chars.length; i += 1) {
2353
- const gram = chars[i] + chars[i + 1]
2354
- out.set(gram, (out.get(gram) ?? 0) + 1)
2355
- }
2356
- return out
2357
- }
2358
- const left = grams(a)
2359
- const right = grams(b)
2360
- let leftTotal = 0
2361
- let rightTotal = 0
2362
- for (const count of left.values()) leftTotal += count
2363
- for (const count of right.values()) rightTotal += count
2364
- if (leftTotal === 0 || rightTotal === 0) return 0
2365
- let overlap = 0
2366
- for (const [gram, count] of left) {
2367
- overlap += Math.min(count, right.get(gram) ?? 0)
2368
- }
2369
- return (2 * overlap) / (leftTotal + rightTotal)
3152
+ return diceSimilarity(a, b)
2370
3153
  }
2371
3154
 
2372
3155
  /**
@@ -3013,7 +3796,7 @@ export interface AdjudicateResult {
3013
3796
  [extra: string]: unknown
3014
3797
  }
3015
3798
 
3016
- export function adjudicateResult({ output, strict = true, expectedAcceptance = [], requirePhases = true }: any): AdjudicateResult {
3799
+ export function adjudicateResult({ output, strict = true, expectedAcceptance = [], requirePhases = true, formatTier, expectedExperts = [] }: any): AdjudicateResult {
3017
3800
  const text = typeof output === 'string' ? output : ''
3018
3801
  const parsed = parseEvidenceBlock(text)
3019
3802
  if (!strict) {
@@ -3254,6 +4037,13 @@ export function adjudicateResult({ output, strict = true, expectedAcceptance = [
3254
4037
  payload,
3255
4038
  text,
3256
4039
  Array.isArray(expectedAcceptance) ? expectedAcceptance.length : 0,
4040
+ /*
4041
+ * [3.0.0] F10/F11 按接收者层级启用:计划行(部门负责人)的结果必须带
4042
+ * departmentSummary(用户要求 10/11),专家结果必须带 report(用户要求 7)。
4043
+ * 调用方不声明层级时两条都不查(历史回放零回归)。
4044
+ */
4045
+ { tier: formatTier === 'expert' ? 'expert' : formatTier === 'leader' ? 'leader' : undefined,
4046
+ expectedExperts: Array.isArray(expectedExperts) ? expectedExperts : [] },
3257
4047
  )
3258
4048
  if (!commFormat.compliant) {
3259
4049
  return {
@@ -3279,6 +4069,13 @@ export function adjudicateResult({ output, strict = true, expectedAcceptance = [
3279
4069
  acceptance,
3280
4070
  artifacts,
3281
4071
  needs,
4072
+ /*
4073
+ * [3.0.0][用户要求 7/10/11] 两级精简 JSON 随判定结果落行:
4074
+ * 专家汇报 report(F10)与部门汇总 departmentSummary(F11)。只透传
4075
+ * 已通过格式门禁的对象,未提供时不下发(旧回放零回归)。
4076
+ */
4077
+ ...(isRecord(payload?.report) ? { report: payload.report } : {}),
4078
+ ...(isRecord(payload?.departmentSummary) ? { departmentSummary: payload.departmentSummary } : {}),
3282
4079
  error: null,
3283
4080
  phases: phaseCheck?.phases ?? null,
3284
4081
  phaseSummary: phaseCheck?.phases ? phaseSummaryLine(phaseCheck.phases) : null,
@@ -3347,23 +4144,94 @@ export function buildUpdateMessage(update: any) {
3347
4144
  * deriveSubtaskTimeoutMs。
3348
4145
  */
3349
4146
  ...(update.timeoutMs === undefined ? {} : { timeoutMs: update.timeoutMs }),
4147
+ /*
4148
+ * [2.3.9][T4b] 梳理门禁与第三层分工必须随 durable workplan-update 回放:
4149
+ * 刷新后门禁判据(consolidation)若只剩内存一份,重启的负责人可以不经
4150
+ * 梳理直接 dispatch,硬门禁就只是「本进程内的礼貌」。delegates 是看板
4151
+ * 第三层的数据源,同理。
4152
+ */
4153
+ ...(update.consolidation === undefined ? {} : { consolidation: update.consolidation }),
4154
+ // [2.5.1] 主 Agent 两轮深度思考产物(计划级,subtaskId=null)随 durable
4155
+ // workplan-update 回放:写入侧 dispatchTool 门禁登记,消费侧 reconstruct
4156
+ // 消毒抬升,刷新/重启后续跑读档放行(G1:写入与消费双侧接线)。
4157
+ ...(update.mainDeepThink === undefined ? {} : { mainDeepThink: update.mainDeepThink }),
4158
+ ...(update.mainDeepThinkPlanId === undefined ? {} : { mainDeepThinkPlanId: update.mainDeepThinkPlanId }),
4159
+ ...(update.delegates === undefined ? {} : { delegates: update.delegates }),
4160
+ // [2.5.4][T3R1] 分派前深度梳理门禁审计(A3)随 durable workplan-update 回放:
4161
+ // 拒绝/放行记录刷新/重启后仍可复核,与 consolidation 同一回放口径。
4162
+ ...(update.gateAudit === undefined ? {} : { gateAudit: update.gateAudit }),
4163
+ ...(update.delegateSelfEfforts === undefined ? {} : { delegateSelfEfforts: update.delegateSelfEfforts }),
4164
+ // [2.5.2] 叶子执行前两轮思考台账随 durable workplan-update 回放(G1 双侧)。
4165
+ ...(update.delegateDeepThinks === undefined ? {} : { delegateDeepThinks: update.delegateDeepThinks }),
4166
+ // [T6][契约v1 §3] 叶子开工前预估台账随 durable workplan-update 回放(G1 双侧):
4167
+ // 刷新/重启后重派读档仍能判定「预估已登记」,8 人预估逐键可查(A2)。
4168
+ ...(update.delegateEstimates === undefined ? {} : { delegateEstimates: update.delegateEstimates }),
4169
+ // [2.5.0] 负责人配置的整体任务等级(用户要求 2「全程应用」)同样随
4170
+ // durable workplan-update 回放:重启后派发链仍优先读它,不回落旧档。
4171
+ ...(update.effortOverride === undefined ? {} : { effortOverride: update.effortOverride }),
3350
4172
  ...(update.revision === undefined ? {} : { revision: update.revision }),
3351
4173
  at: update.at ?? Date.now(),
3352
4174
  }
4175
+ /*
4176
+ * [T7] 可见文本收敛(C1/C2/C3)+信封载体迁移(用户批准选项 A,基线 §8):
4177
+ * - 全量 JSON 信封移入 source.durable(additive 可选键),payload 字段一个
4178
+ * 不改;parseUpdateMessage 先读元数据、回退旧文本标记(旧消息零迁移)。
4179
+ * - 白名单事件(update.keyProgress===true,由调用方按 C1 四态认定)注入
4180
+ * 一行关键进度:ID+新状态+阻塞原因(受阻/待指示时)+下一步+标题,
4181
+ * 单条 ≤500 字符(capKeyProgressText)。
4182
+ * - 其余过程改判(进度/证据/台账登记等)与主 Agent 深度思考登记:可见
4183
+ * 文本置空,信封仍随事件落盘——回放台账不丢(C4),模型上下文零噪音。
4184
+ * - update.keyProgress/title/stateLabel 只是渲染输入,不进 payload。
4185
+ */
4186
+ if (update.mainDeepThink !== undefined && update.subtaskId == null) {
4187
+ const summary = truncate('【两轮深度思考已登记】主 Agent 已完成第一轮任务深研与第二轮方法、流程、步骤(含依据),后续执行按此进行;续跑/重启自动读档,无需重复提交。', 300)
4188
+ return makeUserMessage('', { kind: 'workplan-update', form: 'notice', summary, durable: payload })
4189
+ }
3353
4190
  const summary = truncate(`【状态改判】${update.subtaskId} → ${update.status}`, 300)
3354
- const lines = [
3355
- summary,
3356
- '',
3357
- '这条记录是主 Agent 的人工改判,刷新/重启后按同一顺序回放,不会丢失。',
3358
- '',
3359
- UPDATE_MARKER_BEGIN,
3360
- JSON.stringify(payload),
3361
- UPDATE_MARKER_END,
3362
- ]
3363
- return makeUserMessage(lines.join('\n'), { kind: 'workplan-update', form: 'notice', summary })
4191
+ let text = ''
4192
+ if (update.keyProgress === true) {
4193
+ const closure = typeof update.closure === 'string' ? update.closure : ''
4194
+ const status = typeof update.status === 'string' ? update.status : ''
4195
+ const stateLabel = typeof update.stateLabel === 'string' && update.stateLabel.trim() !== ''
4196
+ ? update.stateLabel.trim()
4197
+ : closure === 'escalated' ? '待指示'
4198
+ : status === 'done' ? '完成'
4199
+ : status === 'blocked' ? '受阻'
4200
+ : status === 'in_progress' ? '开始'
4201
+ : status === 'pending' ? '待执行' : (status || '状态变化')
4202
+ // [T7] 待指示认定:closure=escalated(第一层)或调用方显式 stateLabel
4203
+ // 含「待指示」(第三层请示:行状态可能仍是 in_progress,语义以请示为准)。
4204
+ const awaiting = closure === 'escalated' || String(update.stateLabel ?? '').includes('待指示')
4205
+ const reason = awaiting || status === 'blocked'
4206
+ ? String(update.question ?? update.note ?? update.error ?? '').replace(/\s+/g, ' ').trim()
4207
+ : ''
4208
+ const nextStep = awaiting
4209
+ ? '等待指示:用 dsh_workplan_instruct 答复后恢复执行'
4210
+ : status === 'blocked'
4211
+ ? '主 Agent 裁决:续跑/接手/放弃(dsh_workplan_dispatch/update)'
4212
+ : status === 'done'
4213
+ ? '主 Agent 核验证据与验收后整合(按需:dsh_workplan_status/结算文件)'
4214
+ : '继续执行(按需:dsh_workplan_status)'
4215
+ const title = typeof update.title === 'string' ? update.title.replace(/\s+/g, ' ').trim() : ''
4216
+ // 截断优先级(C3):状态/阻塞原因/下一步在前,标题等修饰信息最后。
4217
+ const parts = [`【关键进度】${update.subtaskId} ${stateLabel}`]
4218
+ if (reason) parts.push(`原因:${truncate(reason, 200)}`)
4219
+ parts.push(`下一步:${nextStep}`)
4220
+ if (title) parts.push(truncate(title, 60))
4221
+ text = capKeyProgressText(parts.join('|'))
4222
+ }
4223
+ return makeUserMessage(text, { kind: 'workplan-update', form: 'notice', summary, durable: payload })
3364
4224
  }
3365
4225
 
3366
4226
  export function parseUpdateMessage(message: any) {
4227
+ /*
4228
+ * [T7] 先读元数据信封(source.durable,选项 A),回退旧文本标记:
4229
+ * 旧会话消息零迁移,新旧两种载体都能回放全量台账(C4/AC-4)。
4230
+ */
4231
+ const durable = message?.source?.durable
4232
+ /* [2.5.5][T10] 合并汇总信封由 parseUpdateMessages 展开,单条解析不接管。 */
4233
+ if (isRecord(durable) && Array.isArray(durable.updates)) return null
4234
+ if (isRecord(durable) && durable.kind === 'workplan-update') return durable
3367
4235
  const body = extractBetween(messageText(message), UPDATE_MARKER_BEGIN, UPDATE_MARKER_END)
3368
4236
  if (!body) return null
3369
4237
  try {
@@ -3375,6 +4243,22 @@ export function parseUpdateMessage(message: any) {
3375
4243
  }
3376
4244
  }
3377
4245
 
4246
+ /**
4247
+ * [2.5.5][T10] 回放用:把一条事件展开成 0..N 条 workplan-update。
4248
+ *
4249
+ * 合并汇总消息的 `source.durable.updates` 按写入顺序返回(保序等价于逐条
4250
+ * 追加);普通消息返回 `[parseUpdateMessage(...)]` 或空数组。回放侧只需把
4251
+ * 原来的「单条应用」代码块包一层 `for`,语义不变。
4252
+ */
4253
+ export function parseUpdateMessages(message: any): any[] {
4254
+ const durable = message?.source?.durable
4255
+ if (isRecord(durable) && Array.isArray(durable.updates)) {
4256
+ return durable.updates.filter((item: any) => isRecord(item))
4257
+ }
4258
+ const single = parseUpdateMessage(message)
4259
+ return single ? [single] : []
4260
+ }
4261
+
3378
4262
  /**
3379
4263
  * Read-only sibling briefing for one child.
3380
4264
  *
@@ -3827,6 +4711,255 @@ export function applyStatus(statuses: any, subtaskId: any, patch: any) {
3827
4711
  .filter((item: any) => isRecord(item) && typeof item.id === 'string')
3828
4712
  .map((item: any) => ({ id: item.id, reason: truncate(String(item.reason ?? ''), 300) }))
3829
4713
  }
4714
+ /*
4715
+ * [2.3.9][T4b] 第三层派发的留档字段(用户要求 4/5:负责人「先全面梳理、
4716
+ * 再分配」的硬门禁产物 + 顶尖专家/组员的分工与实时状态)。
4717
+ *
4718
+ * `consolidation` 是梳理门禁的唯一判据:没有它,delegateTool 的 dispatch
4719
+ * 动作必须被拒(A4)。`delegates` 是看板第三层的渲染数据源(A3),其
4720
+ * requested/corrected 对就是等级钳制的留痕(A5)。两者只写同一条状态行、
4721
+ * 走同一个 durable workplan-update 回放,刷新/重启后门禁与看板不失效。
4722
+ */
4723
+ if (patch.consolidation !== undefined) {
4724
+ if (patch.consolidation === null) next.consolidation = null
4725
+ else if (isRecord(patch.consolidation)) {
4726
+ const briefStrings = (value: any, limit: number, itemMax: number) => (Array.isArray(value) ? value : [])
4727
+ .map((entry: any) => truncate(String(entry ?? '').trim(), itemMax))
4728
+ .filter(Boolean)
4729
+ .slice(0, limit)
4730
+ next.consolidation = {
4731
+ problemAnalysis: briefStrings(patch.consolidation.problemAnalysis, 12, 500),
4732
+ constraints: briefStrings(patch.consolidation.constraints, 12, 300),
4733
+ unknowns: briefStrings(patch.consolidation.unknowns, 12, 300),
4734
+ approach: briefStrings(patch.consolidation.approach, 12, 500),
4735
+ // [2.5.1] 两轮深度思考协议:第二轮依据随梳理产物消毒落档 + durable 回放。
4736
+ approachBasis: briefStrings(patch.consolidation.approachBasis, 12, 500),
4737
+ assignments: (Array.isArray(patch.consolidation.assignments) ? patch.consolidation.assignments : [])
4738
+ // [2.5.4][T4] D1/D2 配套:消毒上限须 ≥ 合法分工表最大人数(复杂 12,与 llm-rules.ts
4739
+ // MAX_COMPLEX_DELEGATE_MEMBERS 同值——因 llm-rules 依赖 plan 会循环引用,此处不 import,
4740
+ // 改一处须同步另一处);人数判据唯一权威仍是 planDelegations 门禁:非复杂在
4741
+ // review/dispatch 照旧截 6,持久化放宽不绕任何闸。
4742
+ .slice(0, 12)
4743
+ .map((item: any) => ({
4744
+ member: truncate(String(item?.member ?? ''), 80),
4745
+ role: normalizeDeptRole(item?.role),
4746
+ task: truncate(String(item?.task ?? ''), 800),
4747
+ /*
4748
+ * [3.0.0][用户要求 3/6] 质量要求是分工表的必填项,必须随梳理产物
4749
+ * 一起持久化:否则 review 通过、dispatch 读回时字段丢失,会被新闸
4750
+ * 二次拒绝(自查发现:消毒白名单漏字段=派发放行后立刻卡死)。
4751
+ */
4752
+ qualityRequirements: normalizeQualityRequirements(item?.qualityRequirements),
4753
+ /*
4754
+ * [2.5.0] 未显式配档的下级不得在这里被物化成 'low':dispatch 读回
4755
+ * 梳理产物时,缺失档位须保持缺失,才能继承负责人配置的整体任务
4756
+ * 等级(taskReasoningEffort)。旧默认 'low' 会截断继承链。
4757
+ */
4758
+ ...(REASONING_EFFORTS.includes(item?.reasoningEffort)
4759
+ ? { reasoningEffort: item.reasoningEffort }
4760
+ : {}),
4761
+ ...(item?.requested && item.requested !== item.reasoningEffort
4762
+ ? { requested: String(item.requested) }
4763
+ : {}),
4764
+ })),
4765
+ // [2.5.0] 负责人配置的整体任务等级随梳理产物留档(非法值丢弃不入库)。
4766
+ ...(REASONING_EFFORTS.includes(patch.consolidation.taskReasoningEffort)
4767
+ ? { taskReasoningEffort: patch.consolidation.taskReasoningEffort }
4768
+ : {}),
4769
+ // [2.5.5][T3] 钳制前声明记忆随梳理产物留档(非法值丢弃不入库);
4770
+ // 仅供 low 禁派闸消费,dispatch 读回时防「钳制后 low」误杀复杂声明。
4771
+ ...(typeof patch.consolidation.taskReasoningEffortDeclared === 'string'
4772
+ && REASONING_EFFORTS.includes(patch.consolidation.taskReasoningEffortDeclared)
4773
+ ? { taskReasoningEffortDeclared: patch.consolidation.taskReasoningEffortDeclared }
4774
+ : {}),
4775
+ submittedAt: numberOrNull(patch.consolidation.submittedAt) ?? Date.now(),
4776
+ }
4777
+ } else {
4778
+ throw new PlanError('consolidation 必须是对象或 null', 'INVALID_CONSOLIDATION')
4779
+ }
4780
+ }
4781
+ if (patch.delegates !== undefined) {
4782
+ /*
4783
+ * [T5-channel][契约v1 §3c] 双向通道子对象消毒(fail-closed):必填字段
4784
+ * 缺失/非法 ⇒ 整个子对象丢弃;超限截断。question/text ≤4000、at 正数、
4785
+ * messageId ≤200、delivery 枚举 sent/failed——刷新/回放不丢、不入库脏值。
4786
+ */
4787
+ const channelStrings = (value: any, limit: number) => (Array.isArray(value) ? value : [])
4788
+ .map((entry: any) => truncate(String(entry ?? ''), 300)).filter(Boolean).slice(0, limit)
4789
+ const sanitizeChannelEscalation = (value: any) => {
4790
+ if (!isRecord(value)) return null
4791
+ if (typeof value.question !== 'string' || !value.question.trim()) return null
4792
+ const at = Number(value.at)
4793
+ if (!Number.isFinite(at) || at <= 0) return null
4794
+ if (value.delivery !== 'sent' && value.delivery !== 'failed') return null
4795
+ return {
4796
+ question: truncate(value.question, 4000),
4797
+ options: channelStrings(value.options, MAX_ESCALATION_OPTIONS),
4798
+ needs: channelStrings(value.needs, 10),
4799
+ at,
4800
+ ...(typeof value.messageId === 'string' && value.messageId ? { messageId: truncate(value.messageId, 200) } : {}),
4801
+ delivery: value.delivery,
4802
+ }
4803
+ }
4804
+ const sanitizeChannelInstruction = (value: any) => {
4805
+ if (!isRecord(value)) return null
4806
+ if (typeof value.text !== 'string' || !value.text.trim()) return null
4807
+ const at = Number(value.at)
4808
+ if (!Number.isFinite(at) || at <= 0) return null
4809
+ if (value.delivery !== 'sent' && value.delivery !== 'failed') return null
4810
+ return {
4811
+ text: truncate(value.text, 4000),
4812
+ at,
4813
+ ...(typeof value.messageId === 'string' && value.messageId ? { messageId: truncate(value.messageId, 200) } : {}),
4814
+ delivery: value.delivery,
4815
+ }
4816
+ }
4817
+ next.delegates = (Array.isArray(patch.delegates) ? patch.delegates : [])
4818
+ // [T8][D2 同步] 与 MAX_COMPLEX_DELEGATE_MEMBERS=12 对齐,人数权威仍是 planDelegations 门禁
4819
+ .slice(0, 12)
4820
+ .map((item: any) => ({
4821
+ member: truncate(String(item?.member ?? ''), 80),
4822
+ role: normalizeDeptRole(item?.role),
4823
+ task: truncate(String(item?.task ?? ''), 300),
4824
+ // [3.0.0][用户要求 3/6] 第三层任务书从 delegates 读质量要求,同样不得丢。
4825
+ qualityRequirements: normalizeQualityRequirements(item?.qualityRequirements),
4826
+ effort: REASONING_EFFORTS.includes(item?.effort) ? item.effort : 'low',
4827
+ ...(item?.requested && item.requested !== item.effort ? { requested: String(item.requested) } : {}),
4828
+ // [2.5.0][自配档] 叶子自配档(权威)与钳制留痕/复杂度依据。
4829
+ ...(REASONING_EFFORTS.includes(item?.selfEffort) ? { selfEffort: item.selfEffort } : {}),
4830
+ ...(item?.selfEffortRequested && item.selfEffortRequested !== item.selfEffort ? { selfEffortRequested: String(item.selfEffortRequested) } : {}),
4831
+ ...(typeof item?.complexityRationale === 'string' && item.complexityRationale.trim() ? { complexityRationale: truncate(item.complexityRationale.trim(), 300) } : {}),
4832
+ // [2.5.2] 叶子执行前两轮深度思考产物(与自配档同为任务级配置)。
4833
+ ...(sanitizeMainDeepThink(item?.deepThink) ? { deepThink: sanitizeMainDeepThink(item?.deepThink) } : {}),
4834
+ // [T6][契约v1 §3] 叶子开工前预估(与 selfEffort/deepThink 同为任务级配置):
4835
+ // fail-closed 消毒见 sanitizeDelegateEstimate;非法整体丢弃,8 人预估全部存活(A2)。
4836
+ ...(sanitizeDelegateEstimate(item?.estimate) ? { estimate: sanitizeDelegateEstimate(item?.estimate) } : {}),
4837
+ childId: typeof item?.childId === 'string' ? truncate(item.childId, 200) : null,
4838
+ status: ['running', 'done', 'failed', 'timeout', 'rejected', 'blocked'].includes(item?.status) ? item.status : 'running',
4839
+ summary: typeof item?.summary === 'string' ? truncate(item.summary, 300) : '',
4840
+ error: typeof item?.error === 'string' ? truncate(item.error, 300) : null,
4841
+ startedAt: numberOrNull(item?.startedAt),
4842
+ finishedAt: numberOrNull(item?.finishedAt),
4843
+ /*
4844
+ * [T8] 第三层完成即时通知的幂等标记:与主行 report 完全同口径
4845
+ * (state ∈ sent/failed/pending + at + ref≤300 + turn),消毒后随
4846
+ * delegates 持久化 + durable workplan-update 回放。state='sent' 才算
4847
+ * 「已通知原分派负责人」;failed 留给兜底补发,绝不冒充 sent。
4848
+ * 非法形状整体丢弃(fail-closed);turn 与主行同款物化:无活动轮次
4849
+ * 时为 null(负责人移交第 3 点+验收文件 assertReportKept 同口径)。
4850
+ */
4851
+ ...(isRecord(item?.report) && ['sent', 'failed', 'pending'].includes(item?.report?.state)
4852
+ ? {
4853
+ report: {
4854
+ state: item.report.state,
4855
+ at: numberOrNull(item.report.at),
4856
+ ref: typeof item.report.ref === 'string' ? truncate(item.report.ref, 300) : null,
4857
+ turn: Number.isInteger(Number(item.report.turn)) ? Number(item.report.turn) : null,
4858
+ },
4859
+ }
4860
+ : {}),
4861
+ /*
4862
+ * [T5-channel][契约v1 §3c] 叶子↔负责人双向通道留档:请示/指示的权威
4863
+ * 形状是 escalation/lastInstruction 子对象(消毒见块首),经 applyStatus
4864
+ * + durable workplan-update 回放,刷新/重启后「有一条叶子请示在等负责人
4865
+ * 指示」不丢。扁平 closure/instructionSeq/instructionOverdue/ackedAt/
4866
+ * blockedKind 保留供叶子 ack 三观察点(scheduleDelegateInstructionAck)
4867
+ * 消费——与契约兼容的既有机制,不另造一套状态机。
4868
+ */
4869
+ ...(typeof item?.closure === 'string' && ['escalated', 'instructed', 'acknowledged', 'blocked'].includes(item.closure)
4870
+ ? { closure: item.closure }
4871
+ : {}),
4872
+ ...(numberOrNull(item?.instructionSeq) !== null ? { instructionSeq: numberOrNull(item?.instructionSeq) } : {}),
4873
+ ...(item?.instructionOverdue === true ? { instructionOverdue: true } : {}),
4874
+ ...(numberOrNull(item?.ackedAt) !== null ? { ackedAt: numberOrNull(item?.ackedAt) } : {}),
4875
+ ...(item?.blockedKind === 'no-ack' || item?.blockedKind === 'escalated' ? { blockedKind: item.blockedKind } : {}),
4876
+ ...(sanitizeChannelEscalation(item?.escalation) ? { escalation: sanitizeChannelEscalation(item?.escalation) } : {}),
4877
+ ...(sanitizeChannelInstruction(item?.lastInstruction) ? { lastInstruction: sanitizeChannelInstruction(item?.lastInstruction) } : {}),
4878
+ }))
4879
+ }
4880
+ /*
4881
+ * [2.5.0][自配档] 叶子自配档台账(member→档):任务级配置,尝试重置保留
4882
+ * (与 effortOverride 同语义);重派时读它直接以自配档接续 phase-1。
4883
+ */
4884
+ if (patch.delegateSelfEfforts !== undefined) {
4885
+ if (patch.delegateSelfEfforts === null) next.delegateSelfEfforts = null
4886
+ else if (isRecord(patch.delegateSelfEfforts)) {
4887
+ const entries = Object.entries(patch.delegateSelfEfforts)
4888
+ .filter(([, value]) => typeof value === 'string' && REASONING_EFFORTS.includes(value))
4889
+ .slice(0, 12)
4890
+ next.delegateSelfEfforts = Object.fromEntries(entries.map(([key, value]) => [truncate(String(key), 80), value]))
4891
+ } else {
4892
+ throw new PlanError('delegateSelfEfforts 必须是 member→档位 对象或 null', 'INVALID_DELEGATE_SELF_EFFORTS')
4893
+ }
4894
+ }
4895
+ /*
4896
+ * [2.5.2] 叶子执行前两轮深度思考台账(member→产物):任务级配置,尝试重置
4897
+ * 保留(与 delegateSelfEfforts 同语义);重派时读它直接以已登记思考接续
4898
+ * phase-1。逐成员经 sanitizeMainDeepThink 消毒(非法/篡改丢弃),与写入侧
4899
+ * 同一判据(G1 双侧接线)。
4900
+ */
4901
+ if (patch.delegateDeepThinks !== undefined) {
4902
+ if (patch.delegateDeepThinks === null) next.delegateDeepThinks = null
4903
+ else if (isRecord(patch.delegateDeepThinks)) {
4904
+ const entries = Object.entries(patch.delegateDeepThinks)
4905
+ .map(([key, value]) => [truncate(String(key), 80), sanitizeMainDeepThink(value)] as const)
4906
+ .filter(([, value]) => value !== null)
4907
+ .slice(0, 12)
4908
+ next.delegateDeepThinks = Object.fromEntries(entries)
4909
+ } else {
4910
+ throw new PlanError('delegateDeepThinks 必须是 member→两轮思考产物 对象或 null', 'INVALID_DELEGATE_DEEP_THINKS')
4911
+ }
4912
+ }
4913
+ /*
4914
+ * [T6][契约v1 §3] 叶子开工前预估台账(member→预估对象):任务级配置,尝试
4915
+ * 重置保留(与 delegateSelfEfforts/delegateDeepThinks 同语义);重派读档据此
4916
+ * 判定「预估已登记」。逐成员经 sanitizeDelegateEstimate 消毒(非法丢弃),
4917
+ * 非法形状抛 INVALID_DELEGATE_ESTIMATES(与 delegateSelfEfforts 同错误码口径)。
4918
+ * 上限 12 与 delegates slice(0,12)/MAX_COMPLEX_DELEGATE_MEMBERS 对齐:契约 A2
4919
+ * 要求 8 人预估全部存活,不得沿用旧台账的 6 人截断。
4920
+ */
4921
+ if (patch.delegateEstimates !== undefined) {
4922
+ if (patch.delegateEstimates === null) next.delegateEstimates = null
4923
+ else if (isRecord(patch.delegateEstimates)) {
4924
+ const entries = Object.entries(patch.delegateEstimates)
4925
+ .map(([key, value]) => [truncate(String(key), 80), sanitizeDelegateEstimate(value)] as const)
4926
+ .filter(([, value]) => value !== null)
4927
+ .slice(0, 12)
4928
+ next.delegateEstimates = Object.fromEntries(entries)
4929
+ } else {
4930
+ throw new PlanError('delegateEstimates 必须是 member→预估对象 或 null', 'INVALID_DELEGATE_ESTIMATES')
4931
+ }
4932
+ }
4933
+ /*
4934
+ * [2.5.4][T3R1] 分派前深度梳理门禁审计(T3 A3:门禁状态变化有可复核记录)。
4935
+ * 有界台账(最多 20 条 {at,action,ok,code}):review/dispatch 的每次拒绝与
4936
+ * 放行都留痕,durable 回放同口径消毒。任务级审计历史:尝试重置不清除
4937
+ * (不在下方 reset 清除之列,与 effortOverride 同语义),跨尝试可追溯。
4938
+ */
4939
+ if (patch.gateAudit !== undefined) {
4940
+ next.gateAudit = (Array.isArray(patch.gateAudit) ? patch.gateAudit : [])
4941
+ .filter((item: any) => isRecord(item) && (item.action === 'review' || item.action === 'dispatch' || item.action === 'direct') && typeof item.ok === 'boolean')
4942
+ .map((item: any) => ({
4943
+ at: numberOrNull(item.at) ?? Date.now(),
4944
+ action: item.action,
4945
+ ok: item.ok === true,
4946
+ code: item.ok === true ? null : truncate(String(item.code ?? 'UNKNOWN'), 80),
4947
+ }))
4948
+ .slice(-20)
4949
+ }
4950
+ /*
4951
+ * [2.5.0] 用户要求 2:负责人为整个任务配置的整体推理等级(effortOverride)。
4952
+ * 只接受五档存储全集内的值或 null(清除);非法值拒绝入库,派发链
4953
+ * resolveTaskEffort 与 durable 回放共用这一条消毒规则。
4954
+ */
4955
+ if (patch.effortOverride !== undefined) {
4956
+ if (patch.effortOverride === null) next.effortOverride = null
4957
+ else if (typeof patch.effortOverride === 'string' && REASONING_EFFORTS.includes(patch.effortOverride)) {
4958
+ next.effortOverride = patch.effortOverride
4959
+ } else {
4960
+ throw new PlanError('effortOverride 必须是 low / medium / high / xhigh / max 之一或 null', 'INVALID_EFFORT_OVERRIDE')
4961
+ }
4962
+ }
3830
4963
  /*
3831
4964
  * [1.7.0] Monotonic revision + author.
3832
4965
  *
@@ -3864,6 +4997,12 @@ export function applyStatus(statuses: any, subtaskId: any, patch: any) {
3864
4997
  if (patch.question === undefined) next.question = null
3865
4998
  if (patch.options === undefined) next.options = []
3866
4999
  if (patch.ackOverdue === undefined) next.ackOverdue = false
5000
+ /*
5001
+ * [2.5.4] ④ 超时「待裁决」标记在行已裁决 done 后必须清除:旧实现保留
5002
+ * pendingAdjudication=true,界面/回放对一条已完成的行仍显示「待裁决」,
5003
+ * 误导主 Agent 以为还有未决请示。done 即裁决完成,标记归 false。
5004
+ */
5005
+ next.pendingAdjudication = false
3867
5006
  if (next.finishedAt === null) next.finishedAt = Date.now()
3868
5007
  /*
3869
5008
  * [1.10.0] R-01:「完成」与「失败原因」不能同时成立。
@@ -3948,6 +5087,54 @@ export function applyStatus(statuses: any, subtaskId: any, patch: any) {
3948
5087
  if (patch.blockedBy === undefined) next.blockedBy = undefined
3949
5088
  // [1.10.6] A conflict belongs to one attempt; a reset starts a new one.
3950
5089
  if (patch.artifactConflict === undefined) next.artifactConflict = undefined
5090
+ /*
5091
+ * [2.3.9][T4b] 第三层痕迹属于上一次尝试:重置后新负责人必须重新梳理、
5092
+ * 旧专家/组员的子会话也已随上一attempt终止——留着它们会让新行「看起来
5093
+ * 已梳理/已在派」,门禁(consolidation)与看板(delegates)双双失真。
5094
+ */
5095
+ if (patch.consolidation === undefined) next.consolidation = undefined
5096
+ if (patch.delegates === undefined) next.delegates = undefined
5097
+ /*
5098
+ * [2.5.0][自配档] 叶子自配档是任务级配置不是尝试痕迹:重置时把 delegates
5099
+ * 已登记的 selfEffort 收进 delegateSelfEfforts 保留(显式 patch 优先)。
5100
+ */
5101
+ if (patch.delegateSelfEfforts === undefined) {
5102
+ const selfMap: Record<string, string> = { ...(isRecord(next.delegateSelfEfforts) ? next.delegateSelfEfforts : {}) }
5103
+ for (const item of Array.isArray(current.delegates) ? current.delegates : []) {
5104
+ if (item && typeof item.member === 'string' && REASONING_EFFORTS.includes(item.selfEffort)) selfMap[item.member] = item.selfEffort
5105
+ }
5106
+ if (Object.keys(selfMap).length > 0) next.delegateSelfEfforts = selfMap
5107
+ }
5108
+ /*
5109
+ * [2.5.2] 叶子两轮思考产物同为任务级配置:重置时把 delegates 已登记的
5110
+ * deepThink 收进 delegateDeepThinks 保留(显式 patch 优先),重派读档放行。
5111
+ */
5112
+ if (patch.delegateDeepThinks === undefined) {
5113
+ const thinkMap: Record<string, any> = { ...(isRecord(next.delegateDeepThinks) ? next.delegateDeepThinks : {}) }
5114
+ for (const item of Array.isArray(current.delegates) ? current.delegates : []) {
5115
+ const sanitized = item ? sanitizeMainDeepThink(item.deepThink) : null
5116
+ if (item && typeof item.member === 'string' && sanitized) thinkMap[item.member] = sanitized
5117
+ }
5118
+ if (Object.keys(thinkMap).length > 0) next.delegateDeepThinks = thinkMap
5119
+ }
5120
+ /*
5121
+ * [T6][契约v1 §3] 叶子开工前预估同为任务级配置:重置时把 delegates 已登记
5122
+ * 的 estimate 收进 delegateEstimates 保留(显式 patch 优先),重派读档据此
5123
+ * 判定「预估已登记」,未预估者仍被门禁拦回 phase-0(A1)。
5124
+ */
5125
+ if (patch.delegateEstimates === undefined) {
5126
+ const estimateMap: Record<string, any> = { ...(isRecord(next.delegateEstimates) ? next.delegateEstimates : {}) }
5127
+ for (const item of Array.isArray(current.delegates) ? current.delegates : []) {
5128
+ const sanitized = item ? sanitizeDelegateEstimate(item.estimate) : null
5129
+ if (item && typeof item.member === 'string' && sanitized) estimateMap[item.member] = sanitized
5130
+ }
5131
+ if (Object.keys(estimateMap).length > 0) next.delegateEstimates = estimateMap
5132
+ }
5133
+ /*
5134
+ * [2.5.0] effortOverride 不在重置清除之列:它是负责人为「整个任务」
5135
+ * 配置的等级(用户要求 2 全程应用),不是上一次尝试的痕迹——重试/续跑
5136
+ * 的新负责人仍须沿用它,除非本人重新 review 配置新值。
5137
+ */
3951
5138
  }
3952
5139
  if (patch.status === 'in_progress') {
3953
5140
  if (next.startedAt === null) next.startedAt = Date.now()
@@ -4011,6 +5198,35 @@ export function applyStatus(statuses: any, subtaskId: any, patch: any) {
4011
5198
  'INVALID_CLOSURE_PROJECTION',
4012
5199
  )
4013
5200
  }
5201
+ /*
5202
+ * [2.5.4] ③ 子会话迟到结算不得削弱主 Agent 人工改判(用户 2026-11-12 本会话实锤):
5203
+ * 主 Agent 已以 structured 证据把行裁决 done 后,子会话迟到的结算若携带更弱的
5204
+ * verification/acceptance,旧实现会整体覆盖,把人工复核证据冲掉。这里保留人工
5205
+ * structured 验收不被子会话迟到回报降级(status/closure 仍按迁移表正常推进)。
5206
+ */
5207
+ if (
5208
+ next.updatedBy === 'child'
5209
+ && current.updatedBy === 'agent'
5210
+ && current.status === 'done'
5211
+ && current.verification === 'structured'
5212
+ ) {
5213
+ next.verification = current.verification
5214
+ if (Array.isArray(current.acceptance) && current.acceptance.length > 0) next.acceptance = current.acceptance
5215
+ }
5216
+ /*
5217
+ * [2.5.4] ⑥ 叶子中止/失败时父级完成口径必须显式(用户 2026-11-12 质疑 E1):
5218
+ * 父行 done 但存在 failed/aborted 叶子时,在摘要里点名这些叶子并说明父级完成
5219
+ * 依据是其余证据+主 Agent 复核,而非该叶子自报完成,避免「叶子没做完却说全完成」
5220
+ * 的口径歧义。delegates 明细仍保留供复核。
5221
+ */
5222
+ if (next.status === 'done') {
5223
+ const failedLeaves = (Array.isArray(next.delegates) ? next.delegates : [])
5224
+ .filter((d: any) => d && (d.status === 'failed' || d.status === 'aborted'))
5225
+ .map((d: any) => String(d.member ?? d.childId ?? '?'))
5226
+ if (failedLeaves.length > 0 && typeof next.summary === 'string' && !next.summary.includes('中止/失败叶子')) {
5227
+ next.summary += `(含中止/失败叶子:${failedLeaves.join('、')};父级完成依据为 delegates 其余证据与主 Agent 复核,非该叶子自报完成)`
5228
+ }
5229
+ }
4014
5230
  const copy = statuses.slice()
4015
5231
  copy[index] = next
4016
5232
  return copy
@@ -4052,6 +5268,20 @@ export interface StatusEntry {
4052
5268
  readonly finishedAt: number | null
4053
5269
  readonly summary: string
4054
5270
  readonly error: string | null
5271
+ /** [T7] 读时派生的负责人时长聚合(不持久化);省略/null=无下属分工或已排除(J8/R8)。 */
5272
+ readonly leaderEstimate?: LeaderEstimateSummary | null
5273
+ /**
5274
+ * [SCv2-T4] 判据层字段(用户 2026-11-13 裁决 B/B/B/B/A/A/B;定名清单见
5275
+ * reports/simple-criterion-v2-fields.md)。criterionResult/criterionException/
5276
+ * criterionViolations 为持久化字段(回放白名单已追加透传);attemptWallClockMs
5277
+ * 与 leaderEstimateOverCriterion 为读时派生(不持久化)。全部可选:未生效的
5278
+ * 历史/在途计划载荷逐字不变(Q5-A 不回溯)。
5279
+ */
5280
+ readonly criterionResult?: 'met' | 'unmet' | 'exception-approved' | null
5281
+ readonly criterionException?: import('./criterion.js').CriterionException | null
5282
+ readonly criterionViolations?: ReadonlyArray<Record<string, unknown>>
5283
+ readonly attemptWallClockMs?: number | null
5284
+ readonly leaderEstimateOverCriterion?: boolean
4055
5285
  readonly [extra: string]: unknown
4056
5286
  }
4057
5287
 
@@ -4102,6 +5332,116 @@ function stringOr(value: unknown, fallback: string): string {
4102
5332
  return typeof value === 'string' ? value : fallback
4103
5333
  }
4104
5334
 
5335
+ /*
5336
+ * [T6][契约v1 §3] 叶子开工前预估子对象消毒(fail-closed):declaredMinutes
5337
+ * 必须是正整数分钟(Number.isInteger 且 1..10080,不做字符串强转)、at 正数、
5338
+ * delivery 枚举 sent/failed;reason ≤300(trim 后落档)、messageId ≤200 均可选。
5339
+ * 必填缺失/非法 ⇒ 整个 estimate 丢弃(返回 null),绝不入库脏值——与 T5 通道
5340
+ * 子对象同口径。delegates[].estimate、delegateEstimates 台账、重置保留收集
5341
+ * 三处共用,与写入侧(runtime.ts selfEffortTool)同一判据(G1 双侧接线)。
5342
+ */
5343
+ function sanitizeDelegateEstimate(value: any) {
5344
+ if (!isRecord(value)) return null
5345
+ const minutes = value.declaredMinutes
5346
+ if (!Number.isInteger(minutes) || minutes < 1 || minutes > 10080) return null
5347
+ const at = Number(value.at)
5348
+ if (!Number.isFinite(at) || at <= 0) return null
5349
+ if (value.delivery !== 'sent' && value.delivery !== 'failed') return null
5350
+ return {
5351
+ declaredMinutes: minutes,
5352
+ ...(typeof value.reason === 'string' && value.reason.trim() ? { reason: truncate(value.reason.trim(), 300) } : {}),
5353
+ at,
5354
+ ...(typeof value.messageId === 'string' && value.messageId ? { messageId: truncate(value.messageId, 200) } : {}),
5355
+ delivery: value.delivery,
5356
+ }
5357
+ }
5358
+
5359
+ /**
5360
+ * [T7][lead-decisions J1] 负责人任务时长聚合输出(冻结结构,读时派生、绝不持久化)。
5361
+ *
5362
+ * totalMinutes=全部下属最新 delivery='sent' 预估 declaredMinutes 的算术和(D3:
5363
+ * 不加负责人自身梳理/汇总耗时);reported/expected=已上报/应上报人数;
5364
+ * missing=未上报或消毒为 null 的成员;failed=已上报但 delivery='failed' 的成员。
5365
+ * 仅 reported===expected 时才可表述「负责人任务时长=全部下属预估之和」的完整等式,
5366
+ * 否则必须按「部分和(X/Y)」标注(J1/spec §4 方案 A)。
5367
+ */
5368
+ export interface LeaderEstimateSummary {
5369
+ readonly totalMinutes: number
5370
+ readonly reported: number
5371
+ readonly expected: number
5372
+ readonly missing: string[]
5373
+ readonly failed: string[]
5374
+ }
5375
+
5376
+ /*
5377
+ * [T7][spec R5/F4] 班子作用域(roster):以当前 delegates 为准——第三层 dispatch
5378
+ * 不裁剪 delegateEstimates(runtime.ts:8767 已核实),被移出班子的残留键不计入;
5379
+ * 行重置后 delegates 清空、尚未重派的过渡期按台账键集合(任务级配置保留语义下
5380
+ * 的唯一已知班子),重派后立即以新 delegates 收敛。成员名去重(R1 每成员至多
5381
+ * 计一次);上限 12 与写侧消毒 slice(0,12) 对齐(F4:不得私改上限)。
5382
+ * 纯读辅助:非法 map 形状在此宽容为空(严格 fail-closed 判定在 deriveLeaderEstimate)。
5383
+ */
5384
+ export function leaderEstimateRoster(row: any): string[] {
5385
+ const delegates = Array.isArray(row?.delegates) ? row.delegates : []
5386
+ const members: string[] = []
5387
+ for (const entry of delegates) {
5388
+ const member = entry && typeof entry.member === 'string' ? entry.member : ''
5389
+ if (member !== '' && !members.includes(member)) members.push(member)
5390
+ }
5391
+ if (members.length > 0) return members.slice(0, 12)
5392
+ const map = isRecord(row?.delegateEstimates) ? row.delegateEstimates : {}
5393
+ return Object.keys(map).slice(0, 12)
5394
+ }
5395
+
5396
+ /*
5397
+ * [T7][lead-decisions J1-J8][rules-spec §2/§5] 负责人任务时长=全部下属开工预估之和。
5398
+ *
5399
+ * 读时派生纯函数(J2/A15:不新增任何持久化字段/存储),口径逐条:
5400
+ * - R2/D9:只计每成员最新 delivery==='sent' 的预估;failed/缺失/消毒为 null 一律
5401
+ * 不计入,如实进缺口清单(绝不拿 0 或猜测值凑等式);
5402
+ * - R6:读档先 map 后 delegates[].estimate,与 self_effort 幂等(runtime.ts:8187)
5403
+ * 和重派门禁(runtime.ts:8655)完全一致;
5404
+ * - J3:消毒复用 sanitizeDelegateEstimate(与 sanitizeLeafEstimate 同一判据,
5405
+ * G1 双侧接线),不另写第二套;
5406
+ * - R1:map 键唯一+整对象替换,天然只计最新一条;F5:journal 仅供审计,严禁参和;
5407
+ * - F6/J8:纯读派生,不反写台账,绝不写回 row.timeNotice/timeJournal(O-2a 自报通道不变);
5408
+ * - R8:closure='replanned' 旧行退出 live,返回 null(台账仍随行透传供追溯);
5409
+ * - J8:空 roster(无 delegates 且台账空)⇒ null(「无下属分工」,不得输出 0 分钟
5410
+ * 暗示即刻完成);和必须 Number.isSafeInteger(理论上界 12×10080=120960),
5411
+ * 越界 fail-closed 返回 null 拒绝展示(模型可读面另附异常标注);
5412
+ * - F2/A9:delegateEstimates 整体形状非法 ⇒ 沿用写侧同款 INVALID_DELEGATE_ESTIMATES
5413
+ * 显式传播,绝不在非法 map 上静默求和(挂载读路径消费的都是写侧已消毒落档值)。
5414
+ */
5415
+ export function deriveLeaderEstimate(row: any): LeaderEstimateSummary | null {
5416
+ const rawMap = row?.delegateEstimates
5417
+ if (rawMap !== undefined && rawMap !== null && !isRecord(rawMap)) {
5418
+ throw new PlanError('delegateEstimates 必须是 member→预估对象 或 null', 'INVALID_DELEGATE_ESTIMATES')
5419
+ }
5420
+ if (row?.closure === 'replanned') return null
5421
+ const roster = leaderEstimateRoster(row)
5422
+ if (roster.length === 0) return null
5423
+ const map = isRecord(rawMap) ? rawMap : {}
5424
+ const delegates = Array.isArray(row?.delegates) ? row.delegates : []
5425
+ let totalMinutes = 0
5426
+ let reported = 0
5427
+ const missing: string[] = []
5428
+ const failed: string[] = []
5429
+ for (const member of roster) {
5430
+ const estimate = sanitizeDelegateEstimate(map[member])
5431
+ ?? sanitizeDelegateEstimate(delegates.find((entry: any) => entry?.member === member)?.estimate)
5432
+ if (estimate && estimate.delivery === 'sent') {
5433
+ totalMinutes += estimate.declaredMinutes
5434
+ reported += 1
5435
+ } else if (estimate && estimate.delivery === 'failed') {
5436
+ failed.push(member)
5437
+ } else {
5438
+ missing.push(member)
5439
+ }
5440
+ }
5441
+ if (!Number.isSafeInteger(totalMinutes)) return null
5442
+ return { totalMinutes, reported, expected: roster.length, missing, failed }
5443
+ }
5444
+
4105
5445
  /**
4106
5446
  * Structurally normalise one entry without touching the clock.
4107
5447
  *
@@ -4141,6 +5481,33 @@ export function normaliseStatusEntry(entry: any): StatusEntry {
4141
5481
  * 界面按 status 原样展示,与旧版完全一致。
4142
5482
  */
4143
5483
  const closure = CLOSURES.includes(source.closure) ? source.closure : null
5484
+ /*
5485
+ * [T7][lead-decisions J2/G2] 负责人时长聚合挂载荷行:读时派生纯函数,不持久化
5486
+ * (A15)。serialisePlan 是实时/回放共用出口且经 derivePlanSnapshot 走本函数,
5487
+ * 看板载荷与模型可读面(modelStatusLines 挂同一函数)构造上同源。
5488
+ * null(空 roster/replanned 旧行/越界 fail-closed)⇒ 省略字段,客户端整行隐藏(J8)。
5489
+ */
5490
+ const leaderEstimate = deriveLeaderEstimate(source)
5491
+ /*
5492
+ * [SCv2-T4][Q6-A/C29] 单次尝试墙钟读时派生:只认 startedAt/finishedAt 时间戳,
5493
+ * 缺失(含预算重置清空)⇒ null「未验证」,绝不按 0 分钟展示。pending 行无计时。
5494
+ * [SCv2-T4][Q4-B/C21/C22] 超判据布尔由服务端下发(客户端严禁算术):
5495
+ * 有叶子=预估之和 >10;无叶子直做=负责人自身开工预估 >10(D-2 推荐 A)。
5496
+ * [SCv2-T4][C08] 判据持久化字段 fail-closed 消毒:非法值降级为 null/剔除,
5497
+ * 绝不把脏值透传给看板/模型(与 noticeChannel 同纪律)。
5498
+ */
5499
+ const attemptWallClockMs = status === 'pending' ? null : attemptWallClockMsOf(source)
5500
+ const criterionException = sanitizeCriterionException(source.criterionException)
5501
+ const criterionResult = CRITERION_RESULTS.includes(source.criterionResult) ? source.criterionResult : null
5502
+ const criterionViolations = Array.isArray(source.criterionViolations)
5503
+ ? source.criterionViolations.filter((item: any) => item !== null && typeof item === 'object' && !Array.isArray(item)).slice(-20)
5504
+ : null
5505
+ const exAnteForOver = leaderEstimate
5506
+ ? { minutes: leaderEstimate.totalMinutes }
5507
+ : (source.timeNotice && Number.isFinite(Number(source.timeNotice.declaredMinutes))
5508
+ ? { minutes: Number(source.timeNotice.declaredMinutes) }
5509
+ : null)
5510
+ const leaderEstimateOverCriterion = exAnteForOver !== null && exAnteForOver.minutes > CRITERION_TARGET_MINUTES
4144
5511
  return {
4145
5512
  ...source,
4146
5513
  subtaskId: stringOr(source.subtaskId, ''),
@@ -4157,6 +5524,18 @@ export function normaliseStatusEntry(entry: any): StatusEntry {
4157
5524
  summary: stringOr(source.summary, ''),
4158
5525
  error,
4159
5526
  ...(lastError ? { lastError } : {}),
5527
+ // [T7][J1 冻结结构] 仅非 null 时下发;缺失=无下属分工/已排除,客户端整行隐藏。
5528
+ ...(leaderEstimate ? { leaderEstimate } : {}),
5529
+ /*
5530
+ * [SCv2-T4] 判据层字段挂载:源字段存在才覆盖(消毒后值),不存在则保持
5531
+ * 缺省——旧计划/未生效计划载荷逐字不变(Q5-A)。attemptWallClockMs 与
5532
+ * leaderEstimateOverCriterion 为读时派生,仅在非 null/true 时下发。
5533
+ */
5534
+ ...(source.criterionResult !== undefined ? { criterionResult } : {}),
5535
+ ...(source.criterionException !== undefined ? { criterionException } : {}),
5536
+ ...(source.criterionViolations !== undefined ? { criterionViolations } : {}),
5537
+ ...(attemptWallClockMs !== null ? { attemptWallClockMs } : {}),
5538
+ ...(leaderEstimateOverCriterion ? { leaderEstimateOverCriterion: true } : {}),
4160
5539
  }
4161
5540
  }
4162
5541
 
@@ -4281,6 +5660,12 @@ export function deriveAggregates(statuses: readonly StatusEntry[], expectedTotal
4281
5660
  * a single payload cannot disagree.
4282
5661
  */
4283
5662
  export function derivePlanSnapshot(raw: any, expectedTotal?: number): PlanSnapshot {
5663
+ /*
5664
+ * [T6][契约v1 §3] 预估透传按现有 delegates/stash 口径补齐:normaliseStatusEntry
5665
+ * 以 `...source` 整行展开,delegates[].estimate 与 delegateEstimates 随行进入
5666
+ * 快照(与 delegateSelfEfforts/delegateDeepThinks 同一路径,无独立白名单可漏);
5667
+ * 消毒唯一权威在写侧 applyStatus,读侧不重复消毒、不丢字段。
5668
+ */
4284
5669
  const statuses = normaliseStatuses(raw)
4285
5670
  const { stats, departments } = deriveAggregates(statuses, expectedTotal)
4286
5671
  return { statuses, stats, departments }
@@ -4951,6 +6336,15 @@ export function buildChildPrompt({
4951
6336
  */
4952
6337
  leadAgentId = '',
4953
6338
  leadAgentIdSource = 'none',
6339
+ /*
6340
+ * [2.3.9][T4b] 用户强制要求 3:分配任务时必须把要求 1/2 全文告知相关部门。
6341
+ * 注入唯一事实源在 llm-rules.ts(buildLlmRulesBrief,tier='department');
6342
+ * 由派发调用点传入(plan.ts 不能反向 import llm-rules.ts,会造成循环依赖)。
6343
+ * 空串 = 旧调用方(旧测试/旧路径)零变化;新派发链恒传非空。
6344
+ */
6345
+ llmRulesBrief = '',
6346
+ // [2.5.0][自配档] phase-0→phase-1 接续块(平台注入,不靠模型自觉)。
6347
+ phaseZeroContinuation = '',
4954
6348
  }: any) {
4955
6349
  const noticeTarget = readLeadAgentId(leadAgentId)
4956
6350
  const noticeCall = leadNoticeCallForm(noticeTarget)
@@ -5009,6 +6403,17 @@ export function buildChildPrompt({
5009
6403
  const anchorBlock = anchorText
5010
6404
  ? [`用户原要求(只读锚点,不得改写;sha256 ${String(plan.taskAnchor.sha256 ?? '').slice(0, 12)}…):`, truncate(anchorText, 4000)]
5011
6405
  : []
6406
+ /*
6407
+ * [3.0.0][用户要求 3] 主 Agent 对该任务结果的「质量要求」必须随任务书一起下达,
6408
+ * 让部门负责人明确知道什么算合格。新计划由规划器逐条写出;旧计划缺失时
6409
+ * 回落为「验收标准即质量要求」,并在标题里如实标明来源,绝不空着。
6410
+ */
6411
+ const authoredQuality = normalizeQualityRequirements((subtask as any)?.qualityRequirements)
6412
+ const qualitySource = authoredQuality.length > 0 ? '主 Agent' : '主 Agent(本计划未单列质量要求,等价于下列验收标准)'
6413
+ const qualityBlock = renderQualityRequirementsBlock(
6414
+ authoredQuality.length > 0 ? authoredQuality : (Array.isArray(subtask?.acceptance) ? subtask.acceptance : []),
6415
+ qualitySource,
6416
+ )
5012
6417
  const contradiction = plan?.contradictions?.primary?.statement ?? '(未记录)'
5013
6418
  const stageName = stage?.name ?? '(未命名阶段)'
5014
6419
  const stageGoal = stage?.goal ?? '(未记录目标)'
@@ -5096,6 +6501,7 @@ export function buildChildPrompt({
5096
6501
  `全局任务:${understanding.originalRequest ?? '(未记录)'}`,
5097
6502
  `最终交付物:${understanding.deliverable ?? '(未记录)'}`,
5098
6503
  ...anchorBlock,
6504
+ ...(llmRulesBrief ? ['', String(llmRulesBrief), ''] : []),
5099
6505
  `主要矛盾:${contradiction}`,
5100
6506
  `当前阶段:${stageName}(${stageGoal})`,
5101
6507
  `工作目录:${cwd || '(未知)'}`,
@@ -5112,6 +6518,7 @@ export function buildChildPrompt({
5112
6518
  `输入:${Array.isArray(subtask.inputs) && subtask.inputs.length ? subtask.inputs.join(';') : '无明确输入'}`,
5113
6519
  `输出:${(subtask.outputs ?? []).join(';') || '(未指定)'}`,
5114
6520
  `验收标准(按编号逐条回应,编号不可省略):${(subtask.acceptance ?? []).map((item: any, index: number) => `A${index + 1} ${String(item)}`).join(';') || '(未指定)'}`,
6521
+ qualityBlock,
5115
6522
  `风险:${subtask.risk}`,
5116
6523
  '',
5117
6524
  '依赖子任务的已知结果:',
@@ -5120,6 +6527,7 @@ export function buildChildPrompt({
5120
6527
  ...(handoffBrief ? ['', handoffBrief] : []),
5121
6528
  ...(failure ? [failure] : []),
5122
6529
  ...(resumeHint ? [resumeHint] : []),
6530
+ ...(phaseZeroContinuation ? [phaseZeroContinuation] : []),
5123
6531
  ...(pendingInstruction ? [pendingInstruction] : []),
5124
6532
  '',
5125
6533
  ...threePhasePromptLines(),
@@ -5128,9 +6536,14 @@ export function buildChildPrompt({
5128
6536
  : []),
5129
6537
  '',
5130
6538
  '执行要求:',
6539
+ '- 执行自己的任务必须先完成上方「三阶段工作法」的两轮深度思考(2.5.1 强制):第一轮全面、全盘、深入梳理、研究、思考自己的任务;第二轮基于第一轮完成好的所有结果再全面、全盘、深入地开展梳理、研究和思考,理清具体一步步执行、完美完成任务的方法、流程和步骤(含依据 approachBasis);最后才基于第二轮的方法、流程、步骤开始具体执行与再分配,两轮未完成前禁止动手。',
5131
6540
  '- 以全球顶尖专家标准执行:先诊断根因再动手,产出与证据要能通过同行复核,不交浅层补丁、不遗留问题。',
5132
- '- 只完成本子任务,不擅自扩大范围;不要派生新的 Agent。',
5133
- '- 你没有派发权限,也不能重启或安装任何服务;遇到这类步骤,必须先上报(见下方「遇阻上报」),再停止推进等待指示,不要空转。',
6541
+ // [2.5.0] 根因修复(用户要求 1):旧文案「不要派生新的 Agent / 你没有派发
6542
+ // 权限」与 dsh_workplan_delegate 授权正面冲突,负责人收到两套矛盾指令后
6543
+ // 普遍不敢再分配。现在明确:负责人拥有本部门内再分配权限,禁令只针对
6544
+ // 主计划派发与第四层派生。
6545
+ '- 只完成本子任务,不擅自扩大范围;除下方「本部门再分配权限」允许的 dsh_workplan_delegate 外,不得派生任何其它 Agent。',
6546
+ '- 你没有主计划派发权限,也不能重启或安装任何服务;遇到这类步骤,必须先上报(见下方「遇阻上报」),再停止推进等待指示,不要空转。',
5134
6547
  '- 不得编造事实、文件、命令结果或证据;无法确认时明确写“未验证”。',
5135
6548
  '- 可以读取工作目录、运行必要命令、修改与任务相关的文件。',
5136
6549
  '- 优先使用给定上下文和本地工具;只有任务明确需要最新外部信息时才联网搜索。',
@@ -5138,6 +6551,17 @@ export function buildChildPrompt({
5138
6551
  '- 如果确实无法完成,第一行输出 `BLOCKED: 原因`,并按下方「遇阻上报」给出 question。',
5139
6552
  '- 完成后用简洁中文汇报:做了什么、证据/文件、验收结果、遗留问题。',
5140
6553
  '',
6554
+ // [2.5.0] 用户要求 1/2/3 的负责人授权段:再分配权限 + 整体推理等级配置
6555
+ // + 更简单的多人分工。与 llm-rules.ts buildLlmRulesBrief 同一口径。
6556
+ '本部门再分配权限与推理等级配置(用户强制要求,平台机制保障):',
6557
+ // [2.5.4][T4] D1/D2 人数口径同步(与 llm-rules.ts buildLlmRulesBrief 同源逐字一致)
6558
+ '- 你是本子任务的部门负责人,拥有再分配权限:先用 dsh_workplan_delegate(action="review") 提交两轮深度思考产物(第一轮全面、全盘、深入梳理研究思考自己的任务=problemAnalysis;第二轮基于第一轮全部结果理清方法、流程、步骤=approach;依据对应=approachBasis)与分工表,再用 action="dispatch" 把任务分配给本部门多名相关领域全球顶尖专家(角色只保留 expert,部门组员已按用户要求 9 取消,至少 1 名;low/未配置任务禁止下派——负责人亲自执行,两轮思考产物经 dsh_workplan_delegate(action="direct") 登记(40/40/20 字判据,可选 reasoningEffort="low");复杂任务(medium/high/xhigh/max)合计不少于 8 人且最多 12 人,少于 8 人硬性阻断);未提交梳理产物前 dispatch 会被平台硬门禁拒绝。',
6559
+ '- 分配必须更简单:每位下级只承担单一目标、单一主产物、可独立验收的一项工作;任务描述完整自包含,让下级拿到就能做,不要把多个交付物压给同一个人。',
6560
+ '- 先配置后开工(平台硬规则):你以 phase-0(low 档)启动,唯一职责是评估你接到任务的复杂度,并在 consolidation.taskReasoningEffort 里配置你自己的整体推理等级(轻度=low;qwen 中等=medium、非 qwen 中等=high;qwen 非常复杂=xhigh、非 qwen 非常复杂=max);登记后平台立即以你的自配档接续本会话进入 phase-1(派活/协调/验收/重试决策整个分配过程全程用自配档,重试/续跑不丢)。分工表 per-expert 档仅为建议:每位专家必须在 phase-0 经 self_effort 按自己分到的单项任务复杂度自配自己的等级,专家自配为权威,越界档由平台按当前模型家族合法集合自动钳制并留痕。low(轻度)/未配置任务禁止下派:负责人亲自执行,两轮思考产物经 action="direct" 登记;复杂任务才走 review+dispatch。',
6561
+ '- 第三层专家是叶子层:他们不得再派生第四层;下级结论会送回本会话,收齐后由你汇总核验(必须覆盖全部已派发专家,不得只汇总一部分),再写最终结果块。用 action="status" 随时查看梳理登记与下级进度。',
6562
+ // [T6][契约v1 §6] 负责人须知:下属开工预估即时送达 + 留痕 + 未上报拦截(时长求和归 T7,此处不实现)。
6563
+ '- 下属经 self_effort 上报的开工预估(整数分钟)会即时送达你会话并留痕(kind=estimate);未上报者被平台拦截开工。',
6564
+ '',
5141
6565
  /*
5142
6566
  * [2.2.0][T3/O-2a] 柔性时长协商协议(方案 §2.6 #3:「开工前预告、超预期
5143
6567
  * 预警、完成即回报」;O-1a①+O-2a+O-4a 合并一段,矩阵 Z1 三条款一次插入)。
@@ -5149,9 +6573,9 @@ export function buildChildPrompt({
5149
6573
  * 预告在目标解析阶段必然失败。现在改为:注入真实父会话 id + 用宿主
5150
6574
  * 契约里的字段名 + 明确失败后的确定性重试与留痕,不再有「猜目标」的余地。
5151
6575
  */
5152
- '柔性时长协商协议(不设固定完成时间;时间是协商出来的安全兜底,不是固定交付期限):',
6576
+ '柔性时长协商协议(判据层:完成目标 ≤10 分钟,默认必须达成,超出须用户明确批准并留痕;运行层安全兜底:时间是协商出来的安全兜底,不是固定交付期限、不构成对外承诺):',
5153
6577
  noticeTargetLine,
5154
- `- 开工前先报预估时长(预计完成本子任务要多久就报多久):用 \`${noticeCall}\` 报预估完成时长,新预估覆盖旧预估;预估仅供参考、非承诺,实际时长协商决定。`,
6578
+ `- 开工前先报预估时长(预计完成本子任务要多久就报多久):用 \`${noticeCall}\` 报预估完成时长,新预估覆盖旧预估;预估仅供参考、非承诺,实际时长协商决定;本次计时口径=单次尝试墙钟(本子会话从启动到结算),每次尝试独立计,续跑/重试不累加;你的预估会累加到部门行的 ≤10 分钟判据目标。`,
5155
6579
  `- 发现预计将超预估时,立即用同一个目标报新预估并申请延期(说明还要多久、为什么),不要等超时才预警。`,
5156
6580
  `- 完成即回报:用同一个目标报核心结论(做了什么、证据/文件、验收结果),不要等整轮结束。`,
5157
6581
  ...(noticeTarget
@@ -5183,7 +6607,7 @@ export function buildChildPrompt({
5183
6607
  EVIDENCE_MARKER_BEGIN,
5184
6608
  '{"status":"done","blockedReason":"","phases":{"planning":{"problemAnalysis":["要解决的问题 1(含现状/约束/未知/主要矛盾)"],"constraints":["..."],"unknowns":["..."],"approach":["第 1 步:做什么 → 产出什么 → 如何证明"]},"execution":{"steps":["实际执行的步骤"],"deviations":[]},"verification":{"allPassed":true,"checks":[{"criterion":"A1","method":"怎么验证","evidence":"命令输出/文件/引用"}],"requirementCheck":"逐条核对用户原要求的结果","retrospective":{"problems":["本次遇到的问题(现象+根因)"],"detours":["走过的弯路/返工/无效尝试;确实没有就写 []"],"resolutions":["最终是如何解决的"],"prevention":["以后如何预防再犯:遇到…先…"]}}},"acceptance":[{"criterion":"A1 把上面的验收标准原文抄在这里","result":"pass","evidence":"用命令输出、文件路径或引用证明"}],"artifacts":[{"kind":"file","ref":"相对工作目录的路径"}],"needs":[],"question":"","options":[],"timeSpentMinutes":0,"finalEstimateMinutes":0}',
5185
6609
  EVIDENCE_MARKER_END,
5186
- '- [2.2.9] 盘上结算备份(必做):发送结果块之前,先把同一份 JSON 写入 reports/wp-settlement-<你的子任务 ID>.json(相对工作目录)。收尾消息因异常(error/截断/超时)丢失时,宿主会自动采纳该备份结算,避免「已完成的工作」被误判为「缺失回报」而受阻并级联冻结下游。',
6610
+ '- [2.2.9] 盘上结算备份(必做):发送结果块之前,先把同一份 JSON 写入 reports/wp-settlement-<你的子任务 ID>.json(相对工作目录)。收尾消息因异常(error/截断/超时)丢失时,宿主会自动采纳该备份结算,避免「已完成的工作」被误判为「缺失回报」而受阻并级联冻结下游。[2.5.2][T4b] 备份 JSON 顶层必须带 planId 与 subtaskId(childId 若已知也带上),且必须是本次执行新写(覆盖同名旧文件):宿主采纳前会校验新鲜度(文件修改时间不早于本次尝试开始时间)与归属(planId/subtaskId 必须匹配本计划/本子任务),陈旧或跨计划的备份会被拒绝采纳并留审计痕。',
5187
6611
  '- status 只能是 done / blocked / partial;partial 会被当作受阻处理。',
5188
6612
  '- acceptance 必须逐条覆盖上面的验收标准:criterion 以 A1、A2… 开头对号入座(编号不可省略);result 只能是 pass / fail / unverified。无法确认就写 unverified,不要写 pass。',
5189
6613
  '- artifacts 写你实际产出或修改的文件(kind=file,ref 用相对路径)、链接(kind=url)或说明(kind=note)。',
@@ -5204,8 +6628,14 @@ export function buildChildPrompt({
5204
6628
  * 规范文本与主 Agent 核验结果用的是同一份数据(src/comm-format.ts),
5205
6629
  * 「附带的要求」与「核验的尺子」由此不可能长成两个版本。
5206
6630
  */
5207
- renderCommFormatSpec(),
5208
- '提交前自查(强制):逐条对照上面《沟通交流格式规范》F1–F9,确认全部满足后再提交;'
6631
+ /*
6632
+ * [3.0.0][用户要求 8/10/11] 部门汇总契约:负责人必须全面汇总本部门全部专家
6633
+ * 汇报,但汇总本身必须精简、禁止累赘重复,并以 JSON 直接交回主 Agent。
6634
+ * 契约文本与门禁(F11)同一事实源。
6635
+ */
6636
+ renderDepartmentSummarySpec(),
6637
+ renderCommFormatSpec('leader'),
6638
+ '提交前自查(强制):逐条对照上面《沟通交流格式规范》F1–F11,确认全部满足后再提交;'
5209
6639
  + '主 Agent 收到结果后按同一份规范逐条核验,任一不合规即立刻退回,你会收到列明不合规条目的退回通知,'
5210
6640
  + '须逐条修正、重新自查通过后再重新提交完整结果。',
5211
6641
  ].join('\n'))