dsh-workplan 3.0.3 → 3.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/runtime.ts CHANGED
@@ -74,6 +74,7 @@ import {
74
74
  isSocialMessage,
75
75
  isTerminalPhase,
76
76
  isStatusQuestion,
77
+ isUserConfirmation,
77
78
  isVagueContinuation,
78
79
  makeUserMessage,
79
80
  markDependentsBlocked,
@@ -147,7 +148,7 @@ import {
147
148
  buildPhaseZeroDelegateePrompt,
148
149
  resolveTaskEffort,
149
150
  } from './llm-rules.js'
150
- import { phaseGateFromErrors, phaseSummaryLine, sanitizeMainDeepThink, validateMainDeepThink, validatePhaseEvidence } from './three-phase.js'
151
+ import { checkStartEvidenceCarryover, phaseGateFromErrors, phaseSummaryLine, sanitizeStartPhaseEvidence, START_EVIDENCE_MIN_CHARS_BRIEF, validateFiveStepEvidence, validateStartPhaseEvidence } from './five-step.js'
151
152
  import {
152
153
  lessonStats,
153
154
  rankLessons,
@@ -355,6 +356,67 @@ export function describeSubagentActivationError(error: any, context: string): Er
355
356
  return error instanceof Error ? error : new Error(raw || String(error))
356
357
  }
357
358
 
359
+ /**
360
+ * [3.0.6][第 2 批] 宿主并发上限的“排队”而不是“判失败”。
361
+ *
362
+ * 宿主 `maxActiveSubagents`(默认 8)按**整棵会话树**共享;插件三层体系
363
+ * (5 个负责人 + 每人再派专家)很容易在某一刻撞上限。旧实现把
364
+ * `ACTIVATION_LIMIT_REACHED` 当普通失败:重试一次仍满就整行 `blocked`,
365
+ * 用户什么都没做错却看到“任务失败”。
366
+ *
367
+ * 现在在 `startActivation` 外层做**有界等待**:撞上限就退避后再试,直到
368
+ * 有空位、被取消、或等满 {@link ACTIVATION_QUEUE_MAX_WAIT_MS}。等待期间
369
+ * 不写失败状态、不消耗子任务 attempt;只有等满才如实报“仍未等到空位”。
370
+ *
371
+ * 多个等待者共享一个模块级冷却时间,避免同一毫秒一起撞门(惊群)。
372
+ * 这不是“精确信号量”(宿主没有暴露当前活跃数),而是“有界排队退避”:
373
+ * 空位一出现,等待者按退避节奏自然补位。
374
+ */
375
+ export const ACTIVATION_QUEUE_MAX_WAIT_MS = 10 * 60 * 1000
376
+ const ACTIVATION_QUEUE_BASE_DELAY_MS = 1000
377
+ const ACTIVATION_QUEUE_MAX_DELAY_MS = 15000
378
+ let activationQueueCooldownUntil = 0
379
+
380
+ export function isActivationLimitError(error: any): boolean {
381
+ if (String(error?.code ?? '') === 'ACTIVATION_LIMIT_REACHED') return true
382
+ return /limit reached/i.test(String(error?.message ?? error ?? ''))
383
+ }
384
+
385
+ export async function startActivationQueued<T>(
386
+ start: () => Promise<T>,
387
+ signal: any,
388
+ context: string,
389
+ ): Promise<T> {
390
+ const beganAt = Date.now()
391
+ let waits = 0
392
+ for (;;) {
393
+ try {
394
+ return await start()
395
+ } catch (error) {
396
+ if (!isActivationLimitError(error)) throw error
397
+ if (signal?.aborted) throw new PlanError('排队等待子代理空位时被取消', 'ABORTED')
398
+ const elapsed = Date.now() - beganAt
399
+ if (elapsed >= ACTIVATION_QUEUE_MAX_WAIT_MS) {
400
+ throw describeSubagentActivationError(
401
+ error,
402
+ `${context}:已排队等待 ${Math.round(elapsed / 1000)} 秒仍未等到空位`,
403
+ )
404
+ }
405
+ waits += 1
406
+ const backoff = Math.min(
407
+ ACTIVATION_QUEUE_MAX_DELAY_MS,
408
+ ACTIVATION_QUEUE_BASE_DELAY_MS * 2 ** Math.min(4, waits - 1),
409
+ )
410
+ const now = Date.now()
411
+ // 全局冷却只增不减:所有等待者共用同一个“下一次可以再试”的时刻。
412
+ activationQueueCooldownUntil = Math.max(activationQueueCooldownUntil, now + backoff)
413
+ const delay = Math.max(250, activationQueueCooldownUntil - now)
414
+ await sleepAbortable(signal, delay + Math.floor(Math.random() * 250))
415
+ if (signal?.aborted) throw new PlanError('排队等待子代理空位时被取消', 'ABORTED')
416
+ }
417
+ }
418
+ }
419
+
358
420
  export function deriveReportPending(record: any): boolean {
359
421
  const statuses = Array.isArray(record?.statuses) ? record.statuses : []
360
422
  /*
@@ -561,6 +623,13 @@ export const DISPOSE_TIMEOUT_MS = 5000
561
623
  export const STALE_PENDING_MS = 10 * 60 * 1000
562
624
  export const MAX_HISTORY_EVENTS = 2000
563
625
  export const MAX_LIVE_SESSIONS = 20
626
+ /**
627
+ * 看板响应上限按**字节**计,而不是 JavaScript 字符串长度。
628
+ * UTF-8 下一个汉字通常 3 字节:旧实现用 `body.length > 2_500_000`,中文响应
629
+ * 实际可发出约 7.5MB,远超注释承诺的 2.5MB。截断后也必须复检,否则 12 个
630
+ * 会话仍可能超限。
631
+ */
632
+ export const MAX_PLANS_RESPONSE_BYTES = 2_500_000
564
633
 
565
634
  function abortError() {
566
635
  return new PlanError('执行已取消', 'ABORTED')
@@ -1423,16 +1492,33 @@ function resultText(result: any) {
1423
1492
  * (keyResults/keyInfo/importantInfo/leadRequirements 四字段齐全、非空、
1424
1493
  * 不重复);缺失或重复即退回(该成员记 failed 并附 F10 拒因),绝不记 done。
1425
1494
  *
1426
- * 最小侵入、只拦 done 路径:结果块无法解析 / 声明 blocked/partial 时维持原
1427
- * 语义(受阻诊断归 escalate/instruct 通道),F1–F9 与三阶段既有判定不在此
1428
- * 重复;replay/读档路径不经这两个回调,行为零变化。
1495
+ * 最小侵入、只拦 done 路径:F1–F9 与三阶段既有判定不在此重复;replay/读档
1496
+ * 路径不经这两个回调,行为零变化。
1497
+ *
1498
+ * [修复] 与主链路「非法 JSON 绝不计 done」同一口径(T4 契约):
1499
+ * - 结果块缺失 / JSON 无法解析:旧实现返回 ok:true,这类汇报被**记成成员
1500
+ * done**(看板虚报完成,与 executeSubtask 的 EVIDENCE_UNPARSABLE 闸矛盾);
1501
+ * 现在记 failed 并附拒因,负责人核实产物后可重派。
1502
+ * - 声明 blocked/partial:旧实现同样记 done;现在记 failed,受阻原因随拒因
1503
+ * 交负责人(escalate 工具已登记 escalation 的行不受本判定影响——结算回调
1504
+ * 里 escalation 优先于 done/failed)。
1429
1505
  */
1430
1506
  function adjudicateExpertReport(outcome: any): { ok: true } | { ok: false; rejection: string } {
1431
1507
  const text = resultText(outcome)
1432
1508
  const parsed = parseEvidenceBlock(text)
1433
1509
  const payload = parsed && typeof parsed === 'object' ? parsed.payload : null
1434
- if (!payload || typeof payload !== 'object') return { ok: true }
1435
- if (String(payload.status ?? '') !== 'done') return { ok: true }
1510
+ if (!payload || typeof payload !== 'object') {
1511
+ return {
1512
+ ok: false,
1513
+ rejection: '专家汇报无法结算:结果块缺失或 JSON 无法解析(完成必回报,非法 JSON 绝不计 done);请负责人核实其产物后重派,或按实改判',
1514
+ }
1515
+ }
1516
+ if (String(payload.status ?? '') !== 'done') {
1517
+ return {
1518
+ ok: false,
1519
+ rejection: `专家汇报声明 status=${String(payload.status ?? '(缺失)')}(非 done,不计完成):${truncate(String(payload.blockedReason ?? payload.question ?? '未附原因'), 200)}`,
1520
+ }
1521
+ }
1436
1522
  const report = checkExpertReport((payload as any).report)
1437
1523
  if (!Array.isArray(report.violations) || report.violations.length === 0) return { ok: true }
1438
1524
  return {
@@ -1825,6 +1911,13 @@ function settleFromOutput(
1825
1911
  ?.map((item: any) => String(item?.member ?? ''))
1826
1912
  .filter((name: string) => name !== '') ?? []
1827
1913
  : [],
1914
+ /*
1915
+ * [3.0.8] 开工-结算一致性比对输入:行级 startPhases(review/direct 开工闸
1916
+ * 登记值);历史行无登记 ⇒ undefined,跳过比对(零迁移)。
1917
+ */
1918
+ startPhases: Array.isArray(record?.statuses)
1919
+ ? record.statuses.find((item: any) => item?.subtaskId === subtask?.id)?.startPhases ?? undefined
1920
+ : undefined,
1828
1921
  })
1829
1922
  const checked = checkArtifacts(verdict.artifacts, options.cwd, options.artifactExists)
1830
1923
  const escalated = verdict.status === 'blocked'
@@ -2021,9 +2114,10 @@ function settleFromOutput(
2021
2114
  * Retry policy for one child attempt.
2022
2115
  *
2023
2116
  * A wedged child (no event for the whole idle window) is worth one fresh
2024
- * attempt. `CHILD_NOT_COMPLETED` is retried only while there is more than one
2025
- * idle window left, otherwise the retry itself would just be killed by the same
2026
- * watchdog.
2117
+ * attempt. `CHILD_NOT_COMPLETED` 的预算比较在生产路径上恒真:当前实现没有
2118
+ * 「整轮剩余预算」概念,全部调用点传入 remainingMs=+∞(TOTAL_TIMEOUT_MS=0
2119
+ * 表示不设整轮硬预算),真正的重试上限只有函数开头的 attempt<2。预算比较
2120
+ * 保留给单元测试与将来接入真实整轮预算的场景,注释按此真实契约书写。
2027
2121
  *
2028
2122
  * [1.10.3] 单个子任务撞上 900 秒硬上限时,只要整轮预算还够再跑一轮,就自动重试
2029
2123
  * 一次。用户 2026-11-01 的质疑是对的:此前这一支被无条件 `return false`,
@@ -2061,8 +2155,9 @@ export function shouldRetryAttempt(error: any, attempt: any, remainingMs: any, i
2061
2155
  /*
2062
2156
  * [2.2.8][T7] 结果块解析失败与 CHILD_NOT_COMPLETED 走同一道闸(用户 2026-11-09
2063
2157
  * 报告 T4 事故:非法 JSON 一次即 blocked,并级联阻断下游;子会话其实已完成
2064
- * 工作,只差一个合法回报)。回喂重报要有意义,必须还剩超过一个空闲窗口的
2065
- * 预算;「最多两次」由函数开头的 attempt 上限统一把关,不会无限循环。
2158
+ * 工作,只差一个合法回报)。生产路径 remainingMs=+∞(无整轮预算概念),
2159
+ * 该比较恒真、退化为 attempt<2 上限把关;预算比较保留给单测与将来接入
2160
+ * 真实整轮预算的场景。
2066
2161
  */
2067
2162
  if (code === 'EVIDENCE_UNPARSABLE') {
2068
2163
  return Number(remainingMs) > Number(idleTimeoutMs)
@@ -2071,12 +2166,21 @@ export function shouldRetryAttempt(error: any, attempt: any, remainingMs: any, i
2071
2166
  * [2.2.9] 结果块缺失与 unparsable 同闸(用户 2026-11-10 红字复发族):
2072
2167
  * 结算的唯一载体是收尾消息块,任何异常收尾(error/截断/超时)都会丢;
2073
2168
  * 旧实现 missing 一次即 blocked 并级联冻结下游(看板红字「待裁决/需处理」
2074
- * 反复出现的结构根因之一)。回喂补报(勿重做已完成工作)同样要求剩余
2075
- * 预算大于一个空闲窗口;「最多两次」由函数开头 attempt 上限统一把关。
2169
+ * 反复出现的结构根因之一)。回喂补报(勿重做已完成工作)在生产路径上
2170
+ * remainingMs=+∞、预算比较恒真,由函数开头 attempt<2 上限把关;预算比较
2171
+ * 保留给单测与将来接入真实整轮预算的场景。
2076
2172
  */
2077
2173
  if (code === 'EVIDENCE_MISSING') {
2078
2174
  return Number(remainingMs) > Number(idleTimeoutMs)
2079
2175
  }
2176
+ /*
2177
+ * [修复] 结算闸退回(EVIDENCE_INCOMPLETE:验收未逐条覆盖 / 五步证据不完整 /
2178
+ * 开工-结算证据不一致)与 unparsable/missing 同闸:结果块已解析,缺口清单
2179
+ * 经 previousFailure 回喂同一子会话补报。
2180
+ */
2181
+ if (code === 'EVIDENCE_INCOMPLETE') {
2182
+ return Number(remainingMs) > Number(idleTimeoutMs)
2183
+ }
2080
2184
  return true
2081
2185
  }
2082
2186
 
@@ -2414,7 +2518,8 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2414
2518
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(不阻断派发)。
2415
2519
  notifyDepthOverrideConflict(ctx, typeof record?.plan?.sessionId === 'string' ? record.plan.sessionId : null)
2416
2520
  try {
2417
- activation = await ctx.subagents.startActivation({
2521
+ activation = await startActivationQueued(
2522
+ () => ctx.subagents.startActivation({
2418
2523
  provider: 'spawn',
2419
2524
  label: `${subtask.department}:${subtask.id} ${subtask.title}`.slice(0, 120),
2420
2525
  prompt: [{
@@ -2521,7 +2626,10 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2521
2626
  maxDepth: 2,
2522
2627
  signal: child.controller.signal,
2523
2628
  delivery: 'caller',
2524
- })
2629
+ }),
2630
+ child.controller.signal,
2631
+ `派发子任务 ${subtask.id}(${subtask.title})`,
2632
+ )
2525
2633
  } catch (error) {
2526
2634
  // [3.0.1][P1b] 并发上限翻译为可行动提示;其余错误原样上抛(保持旧行为)。
2527
2635
  throw describeSubagentActivationError(error, `派发子任务 ${subtask.id}(${subtask.title})`)
@@ -2647,7 +2755,7 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2647
2755
  continue
2648
2756
  }
2649
2757
  throw new PlanError(
2650
- 'phase-0 结束但未提交自配推理等级:先配置后开工是平台硬规则——请评估任务复杂度并经 dsh_workplan_delegate(action="review") 配置 consolidation.taskReasoningEffort,平台将以自配档接续;low(轻度)任务请改经 action="direct" 登记两轮思考产物(负责人亲自执行,禁止下派)',
2758
+ 'phase-0 结束但未提交自配推理等级:先配置后开工是平台硬规则——请评估任务复杂度并经 dsh_workplan_delegate(action="review") 配置 consolidation.taskReasoningEffort,平台将以自配档接续;low(轻度)任务请改经 action="direct" 登记开工证据 startPhases(负责人亲自执行,禁止下派)',
2651
2759
  'SELF_EFFORT_MISSING',
2652
2760
  { subtaskId: subtask.id },
2653
2761
  )
@@ -2699,12 +2807,25 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2699
2807
  * 结算严格性不变:非法 JSON 依旧绝不计 done——只修恢复路径。
2700
2808
  */
2701
2809
  const settleRow = record.statuses.find((item: any) => item?.subtaskId === subtask.id)
2810
+ /*
2811
+ * [修复] F11 接通:行上有已派发专家 ⇒ 本行是部门负责人 ⇒ 结算闸按
2812
+ * leader 层级核验 departmentSummary(F11)并按专家名单核 sources 覆盖度。
2813
+ * 口径与 settleFromOutput :1885-1896 逐字同源(此前预裁决路径不传这两项,
2814
+ * F11 在生产路径上从未执行,但提示词宣称存在——提示词与闸门双源矛盾)。
2815
+ */
2816
+ const settleDelegates = Array.isArray(settleRow?.delegates)
2817
+ ? settleRow.delegates.map((item: any) => String(item?.member ?? '')).filter((name: string) => name !== '')
2818
+ : []
2702
2819
  const settleVerdict = settleRow?.closure === 'escalated'
2703
2820
  ? null
2704
2821
  : adjudicateResult({
2705
2822
  output,
2706
2823
  strict: options.strictEvidence !== false,
2707
2824
  expectedAcceptance: Array.isArray(subtask?.acceptance) ? subtask.acceptance : [],
2825
+ // [3.0.8] 开工-结算一致性比对输入(行级登记值,历史行跳过)。
2826
+ startPhases: settleRow?.startPhases ?? undefined,
2827
+ formatTier: settleDelegates.length > 0 ? 'leader' : undefined,
2828
+ expectedExperts: settleDelegates,
2708
2829
  })
2709
2830
  if (settleVerdict && settleVerdict.verification === 'unparsable') {
2710
2831
  const unparsableLanded = probeInterruptedArtifacts(output, subtask, options.cwd, options.artifactExists)
@@ -2737,8 +2858,7 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2737
2858
  * 附在盘产物清单与「只补交结果块、勿重做已完成工作」;重试耗尽才
2738
2859
  * 按实 blocked(既有 settleFromOutput 路径,严格性不变:缺失永不计 done)。
2739
2860
  */
2740
- if (settleVerdict && settleVerdict.verification === 'unverified'
2741
- && /结果块缺失/.test(String(settleVerdict.error ?? ''))) {
2861
+ if (settleVerdict && settleVerdict.missingBlock === true) {
2742
2862
  const settleBackup = join(options.cwd ?? process.cwd(), 'reports', `wp-settlement-${subtask.id}.json`)
2743
2863
  let backupVerdict: any = null
2744
2864
  let backupText = ''
@@ -2788,8 +2908,13 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2788
2908
  output: backupText,
2789
2909
  strict: true,
2790
2910
  expectedAcceptance: Array.isArray(subtask?.acceptance) ? subtask.acceptance : [],
2911
+ // [3.0.8] 开工-结算一致性比对输入(行级登记值,历史行跳过)。
2912
+ startPhases: settleRow?.startPhases ?? undefined,
2913
+ // [修复] 备份采纳与消息路径同一 F11 口径(见 settleVerdict 处注释)。
2914
+ formatTier: settleDelegates.length > 0 ? 'leader' : undefined,
2915
+ expectedExperts: settleDelegates,
2791
2916
  })
2792
- if (!backupVerdict || /结果块缺失|无法解析/.test(String(backupVerdict.error ?? ''))) backupVerdict = null
2917
+ if (!backupVerdict || backupVerdict.missingBlock === true || backupVerdict.verification === 'unparsable') backupVerdict = null
2793
2918
  }
2794
2919
  }
2795
2920
  } catch {
@@ -2824,6 +2949,27 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2824
2949
  throw missingError
2825
2950
  }
2826
2951
  }
2952
+ /*
2953
+ * [修复] 结果块已解析、但结算闸退回(验收未逐条覆盖 / 五步证据不完整 /
2954
+ * 开工-结算证据不一致)= 与 unparsable/missing 同族的有界回喂重试。
2955
+ *
2956
+ * 结构性根因:旧实现里这类缺口一次即 blocked、无任何回喂,子 Agent 不知道
2957
+ * 差在哪,主 Agent 只能人工重派——「五步证据不完整」反复出现的直接原因。
2958
+ * 现在把校验器给出的具体缺口清单经 previousFailure 回喂同一子会话:
2959
+ * 勿重做已完成的工作,按缺口补全证据后重新回报完整结构化结果块;
2960
+ * 最多两次由 attempt 上限统一把关,重试耗尽仍按实 blocked(严格性不变)。
2961
+ */
2962
+ if (settleVerdict && settleVerdict.verification === 'unverified' && settleVerdict.rereport === true) {
2963
+ const incompleteError = new PlanError(
2964
+ `结果块已解析,但结算闸退回(本次回报不能计完成):${truncate(String(settleVerdict.error ?? ''), 600)}`
2965
+ + '——请勿重做已完成的工作,按上述缺口补全证据后重新回报完整结构化结果块',
2966
+ 'EVIDENCE_INCOMPLETE',
2967
+ { subtaskId: subtask.id },
2968
+ )
2969
+ if (shouldRetryAttempt(incompleteError, attempt, Number.POSITIVE_INFINITY, idleTimeoutMs)) {
2970
+ throw incompleteError
2971
+ }
2972
+ }
2827
2973
  /*
2828
2974
  * [1.7.0] Evidence decides the verdict.
2829
2975
  *
@@ -4297,9 +4443,9 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4297
4443
  /* [1.11.0] 重规划修订号与未处理的变更请求,随 durable 消息回放。 */
4298
4444
  planRevision: number
4299
4445
  changeRequest: any
4300
- /* [2.5.1] 主 Agent 两轮深度思考产物(计划级),随 durable workplan-update 回放。 */
4301
- mainDeepThink: any
4302
- mainDeepThinkPlanId: string | null
4446
+ /* [3.0.8] 主 Agent 五步第 1/2/3 步开工证据(计划级),随 durable workplan-update 回放。 */
4447
+ mainStartPhases: any
4448
+ mainStartPhasesPlanId: string | null
4303
4449
  /* [3.0.1] 认可闸门(计划级)随回放快照透传:刷新/重启后 dispatch 闸门读档生效。 */
4304
4450
  dispatchHold?: any
4305
4451
  gateHistory?: any[]
@@ -4333,8 +4479,8 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4333
4479
  errors: [],
4334
4480
  planRevision: Number(plan?.planRevision ?? 0) || 0,
4335
4481
  changeRequest: null,
4336
- mainDeepThink: null,
4337
- mainDeepThinkPlanId: null,
4482
+ mainStartPhases: null,
4483
+ mainStartPhasesPlanId: null,
4338
4484
  dispatchHold: undefined,
4339
4485
  gateHistory: undefined,
4340
4486
  }
@@ -4484,17 +4630,17 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4484
4630
  /* [2.5.5][T10] 合并汇总消息按序展开成多条 update,逐条应用(与逐条落盘等价)。 */
4485
4631
  for (const update of parseUpdateMessages(event.data)) {
4486
4632
  /*
4487
- * [2.5.1] 主 Agent 两轮深度思考产物回放(计划级字段):写入侧
4488
- * (dispatchTool 门禁登记)把 mainDeepThink/mainDeepThinkPlanId 随
4633
+ * [3.0.8] 主 Agent 开工证据回放(计划级字段):写入侧
4634
+ * (dispatchTool 开工闸登记)把 mainStartPhases/mainStartPhasesPlanId 随
4489
4635
  * durable workplan-update 落盘(subtaskId=null,不挂任何子任务行);
4490
- * 消费侧同一判据消毒(sanitizeMainDeepThink)后抬进计划快照——刷新/
4636
+ * 消费侧同一判据消毒(sanitizeStartPhaseEvidence)后抬进计划快照——刷新/
4491
4637
  * 重启后续跑读档放行,不必重新提交;旧日志无该字段零迁移不报错。
4492
4638
  */
4493
- if (update && typeof update.planId === 'string' && update.mainDeepThink !== undefined) {
4494
- const deepThinkSnap = snapshots.get(update.planId)
4495
- if (deepThinkSnap) {
4496
- deepThinkSnap.mainDeepThink = sanitizeMainDeepThink(update.mainDeepThink)
4497
- deepThinkSnap.mainDeepThinkPlanId = typeof update.mainDeepThinkPlanId === 'string' ? update.mainDeepThinkPlanId : null
4639
+ if (update && typeof update.planId === 'string' && update.mainStartPhases !== undefined) {
4640
+ const startPhasesSnap = snapshots.get(update.planId)
4641
+ if (startPhasesSnap) {
4642
+ startPhasesSnap.mainStartPhases = sanitizeStartPhaseEvidence(update.mainStartPhases)
4643
+ startPhasesSnap.mainStartPhasesPlanId = typeof update.mainStartPhasesPlanId === 'string' ? update.mainStartPhasesPlanId : null
4498
4644
  }
4499
4645
  }
4500
4646
  /*
@@ -4630,10 +4776,13 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4630
4776
  */
4631
4777
  effortOverride: update.effortOverride,
4632
4778
  consolidation: update.consolidation,
4779
+ // [3.0.8] 行级开工证据(review/direct 登记)回放:applyStatus 同口径
4780
+ // 消毒,undefined 保留旧值——刷新/重启后结算一致性比对与重试蓝图不丢。
4781
+ startPhases: update.startPhases,
4633
4782
  delegates: update.delegates,
4634
4783
  delegateSelfEfforts: update.delegateSelfEfforts,
4635
- // [2.5.2] 叶子执行前两轮思考台账回放(applyStatus 同口径消毒)。
4636
- delegateDeepThinks: update.delegateDeepThinks,
4784
+ // [3.0.8] 叶子开工证据台账回放(applyStatus 同口径消毒)。
4785
+ delegateStartPhases: update.delegateStartPhases,
4637
4786
  // [T6][契约v1 §3] 第三层开工预估台账回放(applyStatus 同口径消毒,
4638
4787
  // undefined 保留旧值):刷新/重启后预估不丢,重派读档门禁据此判定。
4639
4788
  delegateEstimates: update.delegateEstimates,
@@ -4829,6 +4978,40 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4829
4978
  }
4830
4979
  const plan = chosen.plan
4831
4980
  const statuses = chosen.statuses
4981
+ /*
4982
+ * [3.0.6][复审修复] 僵尸 in_progress 回收:派发中途进程死亡 → 重启 → 回放
4983
+ * 重建出的行永远停在「正在做」,但没有任何存活 dispatchPromise 在调度它们
4984
+ * (canResumePlan 又只对 executing 放行,结果只能人工逐行改判)。重建路径
4985
+ * 天然不存在运行期派发,因此把残留的 in_progress 降级为 blocked:
4986
+ * 既有 resetBlockedStatuses/dispatch 路径即可正常接管续跑。行级 error 沿用
4987
+ * 本文件 settleStaleInflight(1.8.4)的同款收束写法:保留原说明、缺说明补
4988
+ * 一句人话;另往快照 errors 追加一条计划级留痕。运行期 in_progress 不在此
4989
+ * 误伤——那条路由 serialisePlan 的存活信号(dispatchPromise/turnEnded)收敛。
4990
+ *
4991
+ * 只收「还可能被派发」的计划:cancelled/superseded 的行状态是历史留痕
4992
+ * (workplan-255-cancel-replay R2 钉住取消后行状态原样回放),不做改写。
4993
+ * resultSeen 不豁免——暂停在中途的计划(结果消息已写、行停在 in_progress)
4994
+ * 恰恰是事故本体;而真正收尾的计划行全 done,本循环自然空转。
4995
+ */
4996
+ const ZOMBIE_INFLIGHT_ERROR = '重启后失联:派发中断,需重新派发'
4997
+ const zombieRecoveryApplies = !chosen.cancelled && !chosen.superseded
4998
+ let zombieRecovered = 0
4999
+ if (zombieRecoveryApplies) {
5000
+ for (const row of statuses) {
5001
+ if (row?.status !== 'in_progress') continue
5002
+ row.status = 'blocked'
5003
+ if (typeof row.error !== 'string' || row.error.trim() === '') row.error = ZOMBIE_INFLIGHT_ERROR
5004
+ zombieRecovered += 1
5005
+ }
5006
+ }
5007
+ if (zombieRecovered > 0) {
5008
+ console.warn(
5009
+ `[dsh-workplan] 回放回收 ${zombieRecovered} 条僵尸 in_progress 行`
5010
+ + `(计划 ${String(plan.planId)},派发中断后进程重启):已降级为 blocked,重新派发即可续跑。`,
5011
+ )
5012
+ chosen.errors = [...(chosen.errors ?? []),
5013
+ `${ZOMBIE_INFLIGHT_ERROR}(${zombieRecovered} 项已降级为 blocked,可重新派发续跑)`].slice(-20)
5014
+ }
4832
5015
  const resultPhase = chosen.resultPhase
4833
5016
  const resultSeen = chosen.resultSeen
4834
5017
  const resumeCount = chosen.resumeCount
@@ -4872,9 +5055,9 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4872
5055
  updatedAt: Date.now(),
4873
5056
  createdTurn: plan.createdTurn,
4874
5057
  resumeCount,
4875
- /* [2.5.1] 主 Agent 两轮深度思考产物随回放回到记录(续跑读档放行)。 */
4876
- mainDeepThink: chosen.mainDeepThink ?? null,
4877
- mainDeepThinkPlanId: chosen.mainDeepThinkPlanId ?? null,
5058
+ /* [3.0.8] 主 Agent 开工证据随回放回到记录(续跑读档放行)。 */
5059
+ mainStartPhases: chosen.mainStartPhases ?? null,
5060
+ mainStartPhasesPlanId: chosen.mainStartPhasesPlanId ?? null,
4878
5061
  /* [3.0.1] 认可闸门随重建记录还原:重启后 dispatch 闸门与审计留痕不失效。
4879
5062
  * 直接属性而非条件展开——条件展开会破坏返回字面量的判别收窄
4880
5063
  * (rebuilt.plan 的 null/对象判别失效,resumeLimit 访问报 union 错)。 */
@@ -5002,6 +5185,63 @@ function respondJson(res: any, status: any, payload: any) {
5002
5185
  res.end(body)
5003
5186
  }
5004
5187
 
5188
+ /**
5189
+ * 响应超限时逐级收缩:先减会话数,再丢单会话的大块明细,最后只留摘要。
5190
+ * 任何一级都返回**合法 JSON**;宁可少给字段,也不返回半截字符串。
5191
+ */
5192
+ export function trimPlansPayload(payload: any): any {
5193
+ const fits = (value: any) => Buffer.byteLength(JSON.stringify(value)) <= MAX_PLANS_RESPONSE_BYTES
5194
+ if (fits(payload)) return payload
5195
+ const original = Array.isArray(payload?.sessions) ? payload.sessions.slice() : []
5196
+ let sessions = original.slice()
5197
+ let trimmed: any = { ...payload, truncated: true, sessions }
5198
+ while (!fits(trimmed) && sessions.length > 1) {
5199
+ sessions = sessions.slice(0, Math.max(1, Math.ceil(sessions.length / 2)))
5200
+ trimmed = { ...trimmed, sessions }
5201
+ }
5202
+ if (!fits(trimmed)) {
5203
+ sessions = sessions.map((item: any) => ({
5204
+ sessionId: item.sessionId,
5205
+ planId: item.planId,
5206
+ title: typeof item.title === 'string' ? truncate(item.title, 200) : item.title,
5207
+ phase: item.phase,
5208
+ suspendedPhase: item.suspendedPhase,
5209
+ endedAt: item.endedAt,
5210
+ stats: item.stats,
5211
+ departments: item.departments,
5212
+ statuses: Array.isArray(item.statuses) ? item.statuses.slice(-50) : [],
5213
+ createdAt: item.createdAt,
5214
+ updatedAt: item.updatedAt,
5215
+ running: item.running,
5216
+ deliveryReady: item.deliveryReady,
5217
+ plan: item.plan ? { planId: item.plan.planId, title: item.plan.title } : null,
5218
+ omittedDetail: true,
5219
+ }))
5220
+ trimmed = { ...trimmed, sessions }
5221
+ }
5222
+ if (!fits(trimmed)) {
5223
+ trimmed = {
5224
+ ...trimmed,
5225
+ sessions: sessions.map((item: any) => ({
5226
+ sessionId: item.sessionId,
5227
+ planId: item.planId,
5228
+ title: typeof item.title === 'string' ? truncate(item.title, 120) : item.title,
5229
+ phase: item.phase,
5230
+ omittedDetail: true,
5231
+ })),
5232
+ }
5233
+ }
5234
+ // 极端情况(例如单条 title 本身就巨大):只保留会话计数,保证响应仍是合法 JSON。
5235
+ if (!fits(trimmed)) {
5236
+ trimmed = {
5237
+ ...trimmed,
5238
+ sessions: [],
5239
+ omittedSessions: original.length,
5240
+ }
5241
+ }
5242
+ return trimmed
5243
+ }
5244
+
5005
5245
  export type WorkplanRuntimeOptions = {
5006
5246
  cwd?: string
5007
5247
  /**
@@ -5073,6 +5313,18 @@ export type WorkplanRuntimeOptions = {
5073
5313
  * 以非零退出码结束(packages/bundle/headless/src/index.ts 的 fail())。
5074
5314
  */
5075
5315
  failClosedOnIncomplete?: boolean | 'auto'
5316
+ /**
5317
+ * [3.0.6][第 3 批①] `agent/turn-stopping` 里等待在途规划/派发的上限(毫秒)。
5318
+ *
5319
+ * 审计病根:收尾闸门会无界等待 `planning.promise`(最坏 3 次 × 900s = 45 分钟)
5320
+ * 和 `record.dispatchPromise`(执行无时限 ⇒ 理论上无限),用户取消都没有反应
5321
+ * 窗口。本上限只约束「收尾闸门的等待」,**不**给部门/专家执行加任何时限
5322
+ * (既定语义不变):到点后回合按「等待预算耗尽」如实收尾/失败,后台派发
5323
+ * 继续跑、结果消息照常落盘。
5324
+ *
5325
+ * 默认 60 分钟(3,600,000);`0` = 无限等待(回到旧行为)。
5326
+ */
5327
+ turnStoppingMaxWaitMs?: number
5076
5328
  /**
5077
5329
  * [1.8.13] Package version, supplied by the host from its `meta.version`.
5078
5330
  *
@@ -5215,6 +5467,13 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
5215
5467
  emitSubtaskDoneNotice(recordArg, session, subtask, verdict),
5216
5468
  }
5217
5469
  record.dispatchStartedAt = Date.now()
5470
+ /*
5471
+ * [3.0.6][第 3 批①] 复用同一 record 再派发时清零等待耗尽标记:否则 auto-resume/
5472
+ * continue/重派之后,onTurnStopping 会把下一回合按"已耗尽"零预算秒放行,
5473
+ * 且 waitExhaustedNotifiedTurn 只按 turn 去重,导致每回合误发 ⏳ 上限通知。
5474
+ */
5475
+ record.turnWaitExhausted = undefined
5476
+ record.waitExhaustedNotifiedTurn = undefined
5218
5477
  record.dispatchPromise = dispatchPlan(ctx, record, {
5219
5478
  ...roundOptions,
5220
5479
  signal: controller.signal,
@@ -6453,6 +6712,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
6453
6712
  // 新一轮必须写一条新的结果消息,否则主 Agent 永远看不到自动续跑的结局。
6454
6713
  record.resultWritten = false
6455
6714
  book.doneBefore = Number(live.stats?.done ?? 0)
6715
+ // [3.0.6][第 3 批①] 自动续跑同样复用原 record:派发前清零等待耗尽标记(同 startAutoDispatch)。
6716
+ record.turnWaitExhausted = undefined
6717
+ record.waitExhaustedNotifiedTurn = undefined
6456
6718
  record.dispatchPromise = dispatchPlan(ctx, record, {
6457
6719
  ...base,
6458
6720
  // [2.2.0][T6/O-1a] 自动续跑同样在后台执行:保持完成即时通知。
@@ -6992,6 +7254,27 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
6992
7254
  if (rebuilt?.plan) record = rebuilt
6993
7255
  }
6994
7256
  if (!record?.plan) {
7257
+ /*
7258
+ * [T3][M7 在途可见] 计划尚未落盘、但后台自动分解正在进行时,不得误报"没有计划"
7259
+ * (T1 失效分支 F4:在途不可见曾让用户与主 Agent 误判为"分配器无对象、任务未开始",
7260
+ * 正是本次缺陷的直接观感)。返回 PLANNING_IN_FLIGHT,附带已耗时与明确下一步,
7261
+ * 与真正的 NO_PLAN 区分。仅读取 state.planningInFlight,不写任何状态。
7262
+ */
7263
+ const inFlight = state.planningInFlight?.get(session.id)
7264
+ if (inFlight) {
7265
+ /* [R2 修正] ok 取 false,与 NO_PLAN 一致:在途意味着「还没有可用计划」,避免调用方
7266
+ * 把 ok:true 误读为「已有计划」。code=PLANNING_IN_FLIGHT 与 hint 明确区分原因与下一步。 */
7267
+ return {
7268
+ ok: false,
7269
+ code: 'PLANNING_IN_FLIGHT',
7270
+ running: false,
7271
+ version: pluginVersion,
7272
+ runtime: runtimeIdentity(),
7273
+ elapsedMs: Date.now() - Number(inFlight.startedAt ?? Date.now()),
7274
+ error: '',
7275
+ hint: '任务分解进行中,计划生成后会话将自动出现计划;请稍后再查看,或等待分配通知。',
7276
+ }
7277
+ }
6995
7278
  /*
6996
7279
  * [1.8.14] N1/§14.6 step 2: the identity of the loaded build must be
6997
7280
  * answerable even before a plan exists. 1.8.13 returned NO_PLAN with no
@@ -7116,15 +7399,15 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7116
7399
  }
7117
7400
 
7118
7401
  /**
7119
- * [1.13.0] 阶段三(验证阶段)的插件核验入口(用户 2026-11-05)。
7402
+ * [1.13.0→3.0.8] 第四步(验证阶段)的插件核验入口(用户 2026-11-05;五步口径)。
7120
7403
  *
7121
7404
  * 「按提交内容判阶段」:
7122
- * - 只有 planning + execution 证据齐全,才会进入阶段三核验;
7123
- * - 缺 planning/execution 的调用以 PHASE_GATE 拒绝并列出待补项 —— 这是一道
7124
- * 证据门禁,不是对插件的全局禁用(「阶段一、二禁用插件」只是 2026-11-05
7405
+ * - 只有 planning + preparation + execution 证据齐全,才会进入第四步核验;
7406
+ * - 缺 planning/preparation/execution 的调用以 PHASE_GATE 拒绝并列出待补项 —— 这是一道
7407
+ * 证据门禁,不是对插件的全局禁用(「前三步禁用插件」只是 2026-11-05
7125
7408
  * 当次优化会话的过程约束,2.0.2 起不再作为所有会话的产品规则);
7126
- * - 阶段三核验会逐条检查:问题梳理/可执行思路是否有实质内容、执行步骤
7127
- * 是否记录、验证是否全部通过、验证记录是否覆盖全部验收标准。
7409
+ * - 第四步核验会逐条检查:任务梳理/资源/工具/方案是否有实质内容、准备就绪
7410
+ * 证据是否记录、执行步骤是否记录、验证是否全部通过、验证记录是否覆盖全部验收标准。
7128
7411
  *
7129
7412
  * 它不写状态、不替子 Agent 宣称完成:最终是否 done 仍由 `adjudicateResult`
7130
7413
  * 对同一份 phases 再判一次,避免「核验工具说通过」与「结果块没写」两套真相。
@@ -7132,7 +7415,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7132
7415
  async function verifySubtask(agent: any, args: any) {
7133
7416
  const childSession = agent?.session
7134
7417
  if (!childSession?.id) {
7135
- return { ok: false, code: 'NO_SESSION', passed: false, error: '只能在部门子会话内做阶段三核验' }
7418
+ return { ok: false, code: 'NO_SESSION', passed: false, error: '只能在部门子会话内做第四步核验' }
7136
7419
  }
7137
7420
  const parentId = childSession.header?.parentSession
7138
7421
  if (!parentId) {
@@ -7140,7 +7423,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7140
7423
  ok: false,
7141
7424
  code: 'NOT_CHILD_SESSION',
7142
7425
  passed: false,
7143
- error: '当前不是子会话,无法反查父计划;三阶段核验只对已派发的部门子任务开放',
7426
+ error: '当前不是子会话,无法反查父计划;第四步核验只对已派发的部门子任务开放',
7144
7427
  }
7145
7428
  }
7146
7429
  let record = state.records.get(parentId)
@@ -7169,18 +7452,18 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7169
7452
  const rawPhases = isRecord(args?.phases)
7170
7453
  ? args.phases
7171
7454
  : { planning: args?.planning, preparation: args?.preparation, execution: args?.execution, verification: args?.verification }
7172
- const check = validatePhaseEvidence(rawPhases, expectedAcceptance)
7455
+ const check = validateFiveStepEvidence(rawPhases, expectedAcceptance)
7173
7456
  if (!check.ok || !check.phases) {
7174
7457
  const gate = phaseGateFromErrors(check.errors)
7175
7458
  return {
7176
7459
  ok: false,
7177
7460
  passed: false,
7178
- code: gate === 'phase-1-3' ? 'PHASE_GATE' : 'VERIFICATION_INCOMPLETE',
7461
+ code: gate === 'steps-1-3' ? 'PHASE_GATE' : 'VERIFICATION_INCOMPLETE',
7179
7462
  phase: gate,
7180
7463
  planId: record.plan.planId,
7181
7464
  subtaskId: row.subtaskId,
7182
7465
  gaps: check.errors,
7183
- error: gate === 'phase-1-3'
7466
+ error: gate === 'steps-1-3'
7184
7467
  ? `核验缺少前几步证据:先完成「梳理任务 → 研究资源工具方案 → 准备到位 → 执行」并按步写全证据,再提交验证核验。${check.errors.slice(0, 5).join(';')}`
7185
7468
  : `验证核验未通过:${check.errors.slice(0, 5).join(';')}`,
7186
7469
  }
@@ -7192,7 +7475,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7192
7475
  planId: record.plan.planId,
7193
7476
  subtaskId: row.subtaskId,
7194
7477
  summary: phaseSummaryLine(check.phases),
7195
- message: '插件核验通过:前四步证据齐全、验证全部通过。现在把同一份 phases 写进结果块,并按第五步以 JSON mode 交回本部门负责人。',
7478
+ message: '插件核验通过:第四步证据齐全、验证全部通过。现在把同一份 phases 写进结果块,并按第五步以 JSON mode 交回本部门负责人。',
7196
7479
  }
7197
7480
  }
7198
7481
 
@@ -7353,7 +7636,14 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7353
7636
  const journalInfo = journal.result.ok ? {} : { journal: { ok: false, code: journal.result.code, error: journal.result.error } }
7354
7637
  const revision = Number(row.revision ?? 0) + 1
7355
7638
  const delegates = (Array.isArray(row.delegates) ? row.delegates : []).map((item: any) => (item?.childId === member.childId
7356
- ? { ...item, escalation: { question, options, needs, at: now, ...(messageId ? { messageId } : {}), delivery } }
7639
+ ? {
7640
+ ...item,
7641
+ // [3.0.5] 待指示必须显式落在第三层台账:负责人改派闸门与看板都读这个字段。
7642
+ closure: 'escalated',
7643
+ blockedKind: 'escalated',
7644
+ error: question,
7645
+ escalation: { question, options, needs, at: now, ...(messageId ? { messageId } : {}), delivery },
7646
+ }
7357
7647
  : item))
7358
7648
  record.statuses = applyStatus(record.statuses, row.subtaskId, { delegates, revision, updatedBy: 'child' })
7359
7649
  record.updatedAt = now
@@ -7869,6 +8159,21 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7869
8159
  if (memberName && targetSessionId && target.childId !== targetSessionId) {
7870
8160
  return { ok: false, code: 'NOT_DELEGATE', subtaskId, error: 'member 与 sessionId 指向不同成员,拒绝投递' }
7871
8161
  }
8162
+ /*
8163
+ * [3.0.5] 指示只能答复「已经提交请示」的原专家:这从机制上保证用户要求的
8164
+ * 四步闭环——专家先上报问题,负责人梳理全部任务状态并研究方案后,只能把
8165
+ * 解决方案下发给原专家继续执行;不能借 instruct 把未请示成员当作替代人选。
8166
+ */
8167
+ if (!target?.escalation && target?.closure !== 'escalated') {
8168
+ return {
8169
+ ok: false,
8170
+ code: 'NOT_ESCALATED',
8171
+ subtaskId,
8172
+ member: target?.member,
8173
+ error: `第三层成员 ${String(target?.member ?? '?')} 不在待指示状态:只有已提交请示的原专家才能接收指示。`,
8174
+ hint: '若该成员遇阻,先让其调用 dsh_workplan_escalate;待指示期间禁止 review/dispatch/direct 改派给其他专家。',
8175
+ }
8176
+ }
7872
8177
  const childId = typeof target.childId === 'string' ? target.childId : ''
7873
8178
  if (!childId) {
7874
8179
  return { ok: false, code: 'NOT_DELEGATE', subtaskId, member: target.member, error: '该成员没有登记子会话 childId,无法投递指示' }
@@ -7889,7 +8194,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7889
8194
  // inReplyTo(可选):从留痕回放找该成员最近一条请示消息 id;读失败不阻断投递。
7890
8195
  let inReplyTo = ''
7891
8196
  try {
7892
- const prior = readDeptMessages(record.plan.planId, { kind: 'escalation' })
8197
+ const prior = readDeptMessages(record.plan.planId, { kind: 'escalation', newest: true })
7893
8198
  if (prior.ok) {
7894
8199
  const match = [...prior.messages].reverse().find((m: any) => m.from?.sessionId === childId && m.subtaskId === subtaskId)
7895
8200
  inReplyTo = match?.id ?? ''
@@ -8274,33 +8579,31 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8274
8579
  const rationale = String(args?.complexityRationale ?? '').trim()
8275
8580
  if (!rationale) return { ok: false, code: 'SELF_EFFORT_RATIONALE_MISSING', error: 'complexityRationale 必填:写清你分到的单项任务为何是该复杂度档(事实/依赖/验证难度)。' }
8276
8581
  /*
8277
- * [2.5.2] 叶子执行前两轮深度思考硬门禁(用户 2026-11-12 要求:四角色在
8278
- * 开始具体执行前都被机制强制先思考后执行,且全程少走弯路)。
8582
+ * [3.0.8] 叶子执行前五步第 1/2/3 步开工证据硬门禁(五步工作法单框架;取代
8583
+ * 2.5.2 的两轮深度思考 deepThink 门禁——两轮内容本就是五步第 1、2 步的子集)。
8279
8584
  *
8280
- * 此前专家/组员只有任务书注入 + 结算时 validatePhaseEvidence——思考产物
8281
- * 在「执行后」才被迫补齐,不满足「先思考后执行」。现在把 phase-0 提交
8282
- * 升级为原子对:self_effort 必须同时携带合格 deepThink(与主 Agent/负责人
8283
- * 同一 validateMainDeepThink 判据、同一 40/40/20 字口径),缺交/不合格
8284
- * 硬拒(DEEP_THINK_MISSING / DEEP_THINK_INCOMPLETE),不登记、不接续;
8285
- * 两者齐全才登记并以自配档接续 phase-1——正式执行只能发生在两轮思考
8286
- * 登记之后,且必须按第二轮理清的方法、流程、步骤执行(少走弯路)。
8585
+ * self_effort 必须同时携带合格 startPhases={ planning, preparation }
8586
+ * (与主 Agent/负责人同一 validateStartPhaseEvidence 判据、同一七项字数下限
8587
+ * 口径:problemAnalysis/approach ≥40、approachBasis/resources/prepared/evidence ≥20、
8588
+ * tools ≥10),缺交/不合格硬拒(START_EVIDENCE_MISSING / START_EVIDENCE_INCOMPLETE),
8589
+ * 不登记、不接续;齐全才登记并以自配档接续 phase-1——正式执行只能发生在
8590
+ * 第 1/2/3 步证据登记之后,且必须按第二步理清的方法、流程、步骤执行。
8287
8591
  * 已登记自配档的旧叶子重派直接 phase-1(零迁移),其结算门禁仍验产物。
8288
8592
  */
8289
- const leafDeepThinkCheck = validateMainDeepThink(args?.deepThink)
8290
- if (!leafDeepThinkCheck.ok) {
8291
- const missing = leafDeepThinkCheck.code === 'MAIN_DEEP_THINK_MISSING'
8593
+ const leafStartCheck = validateStartPhaseEvidence(args?.startPhases)
8594
+ if (!leafStartCheck.ok) {
8292
8595
  return {
8293
8596
  ok: false,
8294
- code: missing ? 'DEEP_THINK_MISSING' : 'DEEP_THINK_INCOMPLETE',
8597
+ code: leafStartCheck.code ?? 'START_EVIDENCE_INCOMPLETE',
8295
8598
  subtaskId: String(row.subtaskId),
8296
8599
  member: member.member,
8297
- error: `执行前两轮深度思考产物${missing ? '缺失' : '不合格'}:全球顶尖专家开始执行自己的任务前,必须先全面、全盘、深入梳理、研究、思考自己的任务(第一轮),再基于第一轮完成好的所有结果再全面、全盘、深入地开展梳理、研究和思考,理清具体如何一步步以最高效率、少走弯路、完美完成自己任务的方法、流程和步骤(第二轮),最后才按此执行。请在 self_effort 一并携带 deepThink={ problemAnalysis[], approach[], approachBasis[] }。${leafDeepThinkCheck.error ?? ''}`,
8600
+ error: `开工证据${leafStartCheck.code === 'START_EVIDENCE_MISSING' ? '缺失' : '不合格'}:全球顶尖专家开始执行自己的任务前,必须先完成五步前三步——第一步全面、全盘、深入梳理、研究、思考自己的任务;第二步基于第一步完成好的所有结果研究需要哪些资源、哪些工具、具体实施方案(方法、流程、步骤,含依据);第三步把资源与工具真正备齐并给出就绪证据。请在 self_effort 一并携带 startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }。${leafStartCheck.error ?? ''}`,
8298
8601
  }
8299
8602
  }
8300
- const leafDeepThink = leafDeepThinkCheck.deepThink!
8603
+ const leafStartPhases = leafStartCheck.evidence!
8301
8604
  /*
8302
8605
  * [T6][D9] 开工前预估硬门禁(T6 冻结契约 §2,校验顺序最后一项:
8303
- * reasoningEffort→complexityRationale→deepThink→timeNotice)。timeNotice=
8606
+ * reasoningEffort→complexityRationale→startPhases→timeNotice)。timeNotice=
8304
8607
  * { declaredMinutes: 正整数分钟(1..10080), reason?: ≤300 }。缺交=ESTIMATE_MISSING;
8305
8608
  * 非对象/非整数/越界=ESTIMATE_INVALID;error 必须含 D9 原话+形状说明。拒绝一律
8306
8609
  * 不登记、不投递、不接续(A1)。预估登记后经 T5 通道送达部门负责人(§4)才准
@@ -8369,7 +8672,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8369
8672
  status: written?.status ?? row.status,
8370
8673
  ...(patch.delegates === undefined ? {} : { delegates: written?.delegates }),
8371
8674
  ...(patch.delegateSelfEfforts === undefined ? {} : { delegateSelfEfforts: written?.delegateSelfEfforts }),
8372
- ...(patch.delegateDeepThinks === undefined ? {} : { delegateDeepThinks: written?.delegateDeepThinks }),
8675
+ ...(patch.delegateStartPhases === undefined ? {} : { delegateStartPhases: written?.delegateStartPhases }),
8373
8676
  // [T6][契约v1 §3] 预估台账随 durable workplan-update 回放(重启不丢)。
8374
8677
  ...(patch.delegateEstimates === undefined ? {} : { delegateEstimates: written?.delegateEstimates }),
8375
8678
  revision: written?.revision ?? revision,
@@ -8388,16 +8691,16 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8388
8691
  : { declaredMinutes: rawMinutes, ...(estimateReason ? { reason: estimateReason } : {}), at: Date.now(), delivery: 'failed' }
8389
8692
  const registerList = (currentRow()?.delegates ?? row.delegates)
8390
8693
  .map((d: any) => (d?.childId === childSession.id
8391
- ? { ...d, selfEffort, ...(correction.adjusted ? { selfEffortRequested: raw } : {}), complexityRationale: truncate(rationale, 300), deepThink: leafDeepThink, estimate: estimateDraft, status: 'running', error: null }
8694
+ ? { ...d, selfEffort, ...(correction.adjusted ? { selfEffortRequested: raw } : {}), complexityRationale: truncate(rationale, 300), startPhases: leafStartPhases, estimate: estimateDraft, status: 'running', error: null }
8392
8695
  : d))
8393
8696
  const stash = { ...(currentRow()?.delegateSelfEfforts ?? {}), [member.member]: selfEffort }
8394
- // [2.5.2] 两轮思考产物与自配档同为任务级配置:delegates[].deepThink +
8395
- // delegateDeepThinks 双通道落档,重置保留、durable 回放(G1 双侧接线)。
8396
- const deepThinkStash = { ...(currentRow()?.delegateDeepThinks ?? {}), [member.member]: leafDeepThink }
8697
+ // [3.0.8] 开工证据与自配档同为任务级配置:delegates[].startPhases +
8698
+ // delegateStartPhases 双通道落档,重置保留、durable 回放(G1 双侧接线)。
8699
+ const startPhasesStash = { ...(currentRow()?.delegateStartPhases ?? {}), [member.member]: leafStartPhases }
8397
8700
  // [T6][契约v1 §3] 预估双通道:delegates[].estimate + delegateEstimates(任务级
8398
- // 配置,重置保留、durable 回放),与 selfEffort/deepThink 同范式。
8701
+ // 配置,重置保留、durable 回放),与 selfEffort/startPhases 同范式。
8399
8702
  const estimateStash = { ...(currentRow()?.delegateEstimates ?? {}), [member.member]: estimateDraft }
8400
- persistSelf({ delegates: registerList, delegateSelfEfforts: stash, delegateDeepThinks: deepThinkStash, delegateEstimates: estimateStash })
8703
+ persistSelf({ delegates: registerList, delegateSelfEfforts: stash, delegateStartPhases: startPhasesStash, delegateEstimates: estimateStash })
8401
8704
  /*
8402
8705
  * [T6][D9][契约v1 §4] 预估送达部门负责人:登记之后、interrupt/接续之前。
8403
8706
  * 路由 row.childId(部门行负责人会话),缺失回退 leaderId;两者皆缺 ⇒
@@ -8452,7 +8755,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8452
8755
  code: 'ESTIMATE_DELIVERY_FAILED',
8453
8756
  subtaskId,
8454
8757
  member: member.member,
8455
- error: `预估投递失败(预估已以 delivery:'failed' 落档,未接续执行):${estimateDeliveryError}。请重试 self_effort(携带完整原子对:reasoningEffort+complexityRationale+deepThink+timeNotice),重试将重新投递。`,
8758
+ error: `预估投递失败(预估已以 delivery:'failed' 落档,未接续执行):${estimateDeliveryError}。请重试 self_effort(携带完整原子对:reasoningEffort+complexityRationale+startPhases+timeNotice),重试将重新投递。`,
8456
8759
  ...estimateJournalInfo,
8457
8760
  }
8458
8761
  }
@@ -8469,8 +8772,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8469
8772
  * ① 解析移到 interrupt 之前:ctx.get('agents') 安全访问器(宿主
8470
8773
  * dsh-subagent / dsh-tool-jobs 同款范式),整体 try/catch;无 get 方法
8471
8774
  * 的上下文(旧测试夹具)回退属性访问,同样在 try/catch 内。
8472
- * ② 解析失败 ⇒ 不中断 phase-0;自配档与两轮思考产物已登记保留
8473
- * (delegateSelfEfforts / delegateDeepThinks 已 durable 落档,负责人
8775
+ * ② 解析失败 ⇒ 不中断 phase-0;自配档与开工证据已登记保留
8776
+ * (delegateSelfEfforts / delegateStartPhases 已 durable 落档,负责人
8474
8777
  * 重派该成员时读档直连 phase-1),显式返回
8475
8778
  * SELF_EFFORT_CONTINUATION_FAILED,绝不静默。
8476
8779
  */
@@ -8480,7 +8783,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8480
8783
  leaderAgent = agentsService?.get?.(leaderId) ?? null
8481
8784
  } catch { leaderAgent = null }
8482
8785
  if (!leaderAgent) {
8483
- const message = '自配档与两轮思考产物已登记,但负责人 agent 解析失败(agents 服务不可用):phase-0 未被中断,登记保留——负责人可重派该成员,重派将读档直接以自配档接续 phase-1(禁止静默降档)'
8786
+ const message = '自配档与开工证据已登记,但负责人 agent 解析失败(agents 服务不可用):phase-0 未被中断,登记保留——负责人可重派该成员,重派将读档直接以自配档接续 phase-1(禁止静默降档)'
8484
8787
  const failedList = (currentRow()?.delegates ?? [])
8485
8788
  .map((d: any) => (d?.childId === childSession.id ? { ...d, status: 'failed', error: truncate(message, 300), finishedAt: Date.now() } : d))
8486
8789
  persistSelf({ delegates: failedList })
@@ -8511,7 +8814,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8511
8814
  rulesBrief,
8512
8815
  cwd: typeof childSession.header?.cwd === 'string' ? childSession.header.cwd : '',
8513
8816
  leadSessionId: leaderId,
8514
- extraContext: `【phase-0→phase-1 接续——继续勿重做】你已在 phase-0 完成复杂度评估并自配推理等级 \`${selfEffort}\`(依据:${truncate(rationale, 300)}${correction.adjusted ? `;请求档 ${raw} 越界已被平台钳制为 ${selfEffort}` : ''}),并登记了执行前两轮深度思考产物。平台已按你的自配档接续:直接执行正式任务,不要重新评估复杂度,不要重做 phase-0 已完成的工作。正式执行必须严格按你第二轮理清的方法、流程、步骤进行(你的第二轮产物:${leafDeepThink.approach.join(';').slice(0, 300)}…),全程少走弯路:先查历史教训、先验证再动手、不重复试错。`,
8817
+ extraContext: `【phase-0→phase-1 接续——继续勿重做】你已在 phase-0 完成复杂度评估并自配推理等级 \`${selfEffort}\`(依据:${truncate(rationale, 300)}${correction.adjusted ? `;请求档 ${raw} 越界已被平台钳制为 ${selfEffort}` : ''}),并登记了五步第 1/2/3 步开工证据。平台已按你的自配档接续:直接执行正式任务,不要重新评估复杂度,不要重做 phase-0 已完成的工作。正式执行必须严格按你第二步理清的方法、流程、步骤进行(你的第二步产物:${leafStartPhases.planning.approach.join(';').slice(0, 300)}…),全程少走弯路:先查历史教训、先验证再动手、不重复试错。`,
8515
8818
  })
8516
8819
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(scope=计划根会话)。
8517
8820
  notifyDepthOverrideConflict(ctx, typeof rootId === 'string' ? rootId : null)
@@ -8520,7 +8823,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8520
8823
  for (let i = 0; i < 2; i += 1) {
8521
8824
  try {
8522
8825
  // [2.5.5][治本] 第三处 spawn 同口径:spec 顶层契约(prompt/parent/cwd/agentOptions/maxDepth)。
8523
- activation = await ctx.subagents.startActivation({
8826
+ activation = await startActivationQueued(
8827
+ () => ctx.subagents.startActivation({
8524
8828
  provider: 'spawn',
8525
8829
  label: `${row.department}:${subtaskId}→${member.member}(self:${selfEffort})`.slice(0, 120),
8526
8830
  prompt: [{ type: 'text', text: promptText }],
@@ -8539,7 +8843,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8539
8843
  */
8540
8844
  signal: new AbortController().signal,
8541
8845
  delivery: 'caller',
8542
- })
8846
+ }),
8847
+ undefined,
8848
+ `自配档接续(成员 ${member.member})`,
8849
+ )
8543
8850
  break
8544
8851
  } catch (error) { lastError = error }
8545
8852
  }
@@ -8674,6 +8981,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8674
8981
  subtaskId,
8675
8982
  status: written?.status ?? row.status,
8676
8983
  ...(patch.consolidation === undefined ? {} : { consolidation: written?.consolidation }),
8984
+ // [3.0.8] 行级开工证据随 durable workplan-update 落盘(与 consolidation 同口径)。
8985
+ ...(patch.startPhases === undefined ? {} : { startPhases: written?.startPhases }),
8677
8986
  ...(patch.delegates === undefined ? {} : { delegates: written?.delegates }),
8678
8987
  // [2.5.4][T3R1] 门禁审计随 durable workplan-update 落盘(A3 可复核)。
8679
8988
  ...(patch.gateAudit === undefined ? {} : { gateAudit: written?.gateAudit }),
@@ -8699,6 +9008,31 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8699
9008
  return persist({ gateAudit: [...prior, entry].slice(-20) })
8700
9009
  }
8701
9010
 
9011
+ /*
9012
+ * [3.0.5] 用户改进方案 1/2 的硬机制:第三层任何专家进入「待指示」后,部门负责
9013
+ * 人不得借 review/dispatch/direct 把相关问题改派、重派或降级给其他人;必须先
9014
+ * 全面梳理该问题与本部门全部 delegates 执行状态,研究方案后用 dsh_workplan_
9015
+ * instruct 答复原成员,由原成员继续执行。这里硬拒的是「换人/重派」动作,
9016
+ * status 仍放行,保证负责人能看到当前所有任务状态并履行研究义务。
9017
+ */
9018
+ const openEscalations = (Array.isArray(row.delegates) ? row.delegates : [])
9019
+ .filter((item: any) => Boolean(item?.escalation) || item?.closure === 'escalated')
9020
+ if (openEscalations.length > 0 && ['review', 'dispatch', 'direct'].includes(action)) {
9021
+ const members = openEscalations.map((item: any) => String(item?.member ?? '?'))
9022
+ recordGate(action as 'review' | 'dispatch' | 'direct', false, 'DELEGATE_ESCALATION_OPEN')
9023
+ return {
9024
+ ok: false,
9025
+ code: 'DELEGATE_ESCALATION_OPEN',
9026
+ subtaskId,
9027
+ members,
9028
+ delegates: row.delegates,
9029
+ error: `第三层已有成员待指示(${members.join('、')}):禁止改派、重派或降级给其他人。`
9030
+ + '必须先全面梳理该成员遇到的问题与本部门全部已派发任务的执行状态,研究形成解决方案后,'
9031
+ + '用 dsh_workplan_instruct 答复原成员;平台会强制由原成员继续执行。',
9032
+ hint: '先用 action="status" 查看全部 delegates;对每位待指示成员执行 dsh_workplan_instruct(subtaskId=本部门行 ID,member=待指示成员)。待指示清零后才允许 review/dispatch/direct。',
9033
+ }
9034
+ }
9035
+
8702
9036
  if (action === 'status') {
8703
9037
  const delegates = Array.isArray(row.delegates) ? row.delegates : []
8704
9038
  return {
@@ -8711,6 +9045,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8711
9045
  // [2.5.4][T3R1] 门禁审计对负责人可见(A3:拒绝/放行记录可复核)。
8712
9046
  gateAudit: Array.isArray(row.gateAudit) ? row.gateAudit : [],
8713
9047
  delegates,
9048
+ // [3.0.5] 待指示成员清单:负责人履行「先梳理全部任务状态」义务的读取面。
9049
+ openEscalations: openEscalations.map((item: any) => String(item?.member ?? '?')),
8714
9050
  // [T7][lead-decisions J2] 负责人时长聚合:与看板/模型面同一读时派生纯函数
8715
9051
  // (J1 冻结结构;null=无下属分工/replanned 旧行/越界 fail-closed,J8/R8)。
8716
9052
  leaderEstimate: deriveLeaderEstimate(row),
@@ -8718,21 +9054,23 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8718
9054
  // 且分工表为空/缺失 ⇒ low 直执;复杂任务被钳制到 low 的行(assignments 非空)
8719
9055
  // 不命中,避免误导(规格 §5.6)。
8720
9056
  hint: row.effortOverride === 'low' && (!Array.isArray((row.consolidation as any)?.assignments) || (row.consolidation as any).assignments.length === 0)
8721
- ? 'low 任务(含视同 low):禁止第三层下派,负责人亲自执行;两轮思考产物经 action="direct" 登记(已登记则直接执行)。'
9057
+ ? 'low 任务(含视同 low):禁止第三层下派,负责人亲自执行;开工证据 startPhases 经 action="direct" 登记(已登记则直接执行)。'
8722
9058
  : !row.consolidation
8723
9059
  ? '尚未提交梳理产物:先调用 action="review"(用户要求 4 的硬门禁)。'
8724
9060
  : delegates.length === 0
8725
9061
  ? '梳理产物已登记,可调用 action="dispatch" 正式派发给本部门全球顶尖专家。'
8726
- : '第三层已派发;各下级结论会送回本会话,收齐后汇总核验,再写最终结果块。若有成员 closure=escalated(待指示),必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,不要沉默略过。',
9062
+ : openEscalations.length > 0
9063
+ ? `第三层已有 ${openEscalations.length} 名成员待指示(${openEscalations.map((item: any) => String(item?.member ?? '?')).join('、')}):按 3.0.5 硬规则禁止 review/dispatch/direct 改派;必须先全面梳理该问题与本部门全部任务状态,研究方案后用 dsh_workplan_instruct 答复原成员,由原成员继续执行。`
9064
+ : '第三层已派发;各下级结论会送回本会话,收齐后汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」:必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。',
8727
9065
  }
8728
9066
  }
8729
9067
 
8730
9068
  /*
8731
9069
  * [2.5.5][T3] 用户裁决 D2/D4:low 任务负责人亲自执行登记(direct)。
8732
9070
  * low(含视同 low)任务禁止第三层下派——planDelegations 禁派闸对 review/dispatch
8733
- * 一律硬拒(DELEGATE_LOW_TASK_FORBIDDEN);负责人亲自执行,两轮深度思考产物经
8734
- * 本动作登记(复用 validateMainDeepThink,与主 Agent/叶子/review 同一 40/40/20
8735
- * 判据)。登记 effortOverride='low' ⇒ phase-0 结算闸(runSubtaskAttempt 内
9071
+ * 一律硬拒(DELEGATE_LOW_TASK_FORBIDDEN);负责人亲自执行,五步第 1/2/3 步开工
9072
+ * 证据经本动作登记(复用 validateStartPhaseEvidence,与主 Agent/叶子/review
9073
+ * 同一判据)。登记 effortOverride='low' ⇒ phase-0 结算闸(runSubtaskAttempt 内
8736
9074
  * SELF_EFFORT_MISSING 分支)只查 effortOverride 非空,逻辑零改动即可接续。
8737
9075
  * 防旁路(规格 §5.8):不收 consolidation/分工表;只接受 reasoningEffort='low'
8738
9076
  * (缺省默认 low);已有复杂分工表的行不得降级;下级 running 中不得改走;
@@ -8764,18 +9102,18 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8764
9102
  ok: false,
8765
9103
  code: 'DELEGATE_DIRECT_ASSIGNMENTS_FORBIDDEN',
8766
9104
  subtaskId,
8767
- error: 'direct 不接受 consolidation/分工表(low 任务禁止下派,用户裁决 D2):只提交 deepThink={problemAnalysis[],approach[],approachBasis[]}(40/40/20 字判据)与可选 reasoningEffort="low"。',
9105
+ error: 'direct 不接受 consolidation/分工表(low 任务禁止下派,用户裁决 D2):只提交 startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }(第 1/2/3 步证据,字数下限:' + START_EVIDENCE_MIN_CHARS_BRIEF + ')与可选 reasoningEffort="low"。',
8768
9106
  }
8769
9107
  }
8770
- const think = validateMainDeepThink(args?.deepThink)
8771
- if (!think.ok || !think.deepThink) {
8772
- const code = think.code === 'MAIN_DEEP_THINK_MISSING' ? 'DELEGATE_DIRECT_THINK_MISSING' : 'DELEGATE_DIRECT_THINK_INCOMPLETE'
9108
+ const startCheck = validateStartPhaseEvidence(args?.startPhases)
9109
+ if (!startCheck.ok || !startCheck.evidence) {
9110
+ const code = startCheck.code === 'START_EVIDENCE_MISSING' ? 'DELEGATE_DIRECT_START_MISSING' : 'DELEGATE_DIRECT_START_INCOMPLETE'
8773
9111
  recordGate('direct', false, code)
8774
9112
  return {
8775
9113
  ok: false,
8776
9114
  code,
8777
9115
  subtaskId,
8778
- error: `${think.error ?? '两轮深度思考产物缺失或不合格。'}(direct 登记与主 Agent/叶子同一判据:problemAnalysis 合计 ≥40 字、approach 合计 ≥40 字、approachBasis 合计 ≥20 字。)`,
9116
+ error: `${startCheck.error ?? '开工证据缺失或不合格。'}(direct 登记与主 Agent/叶子同一判据:${START_EVIDENCE_MIN_CHARS_BRIEF}。)`,
8779
9117
  }
8780
9118
  }
8781
9119
  const directEffortRaw = args?.reasoningEffort
@@ -8790,10 +9128,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8790
9128
  }
8791
9129
  const hadEffortOverride = typeof row.effortOverride === 'string' && row.effortOverride.length > 0
8792
9130
  const written = persist({
9131
+ // [3.0.8] 第 1/2/3 步开工证据存行级 startPhases(结算一致性比对读档用)。
9132
+ startPhases: startCheck.evidence,
8793
9133
  consolidation: {
8794
- problemAnalysis: think.deepThink.problemAnalysis,
8795
- approach: think.deepThink.approach,
8796
- approachBasis: think.deepThink.approachBasis,
8797
9134
  assignments: [], // 空分工表=直执标记(派生判据,规格 §5.6)
8798
9135
  taskReasoningEffort: 'low',
8799
9136
  submittedAt: Date.now(),
@@ -8812,7 +9149,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8812
9149
  action: 'direct',
8813
9150
  effortOverride: 'low',
8814
9151
  consolidation: written?.consolidation ?? null,
8815
- hint: 'low 直执已登记(durable,刷新后门禁依然生效):平台将以 low 档接续本会话进入 phase-1。负责人亲自执行本任务,禁止再调用 review/dispatch(low 禁派闸会硬拒);完成后按三阶段契约提交证据与结论。',
9152
+ hint: 'low 直执已登记(durable,刷新后门禁依然生效):平台将以 low 档接续本会话进入 phase-1。负责人亲自执行本任务,禁止再调用 review/dispatch(low 禁派闸会硬拒);完成后按五步契约提交证据与结论。',
8816
9153
  }
8817
9154
  }
8818
9155
 
@@ -8823,7 +9160,19 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8823
9160
  ok: false,
8824
9161
  code: 'MISSING_CONSOLIDATION',
8825
9162
  subtaskId,
8826
- error: 'review 必须携带 consolidation:{ problemAnalysis[], constraints[]?, unknowns[]?, approach[], approachBasis[], assignments[{member, role:"expert", task, qualityRequirements[], reasoningEffort}] }——两轮深度思考产物(第一轮全面、全盘、深入梳理研究思考自己的任务=problemAnalysis;第二轮基于第一轮全部结果理清方法、流程、步骤=approach,依据对应=approachBasis)+ 分工表(至少 1 名、最多 12 名本部门全球顶尖专家;组员角色已取消;每项任务必须极简并附质量要求)。',
9163
+ error: 'review 必须携带 consolidation 分工表:{ assignments[{member, role:"expert", task, qualityRequirements[], reasoningEffort}] },并随附 startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }——五步第 1/2/3 步开工证据(第一步任务梳理;第二步基于第一步全部结果研究资源、工具与具体实施方案;第三步把资源与工具真正备齐并给出就绪证据)+ 分工表(至少 1 名、最多 12 名本部门全球顶尖专家;组员角色已取消;每项任务必须极简并附质量要求)。',
9164
+ }
9165
+ }
9166
+ // [3.0.8] 负责人 review 开工闸:与 direct/dispatch/self_effort 同一
9167
+ // validateStartPhaseEvidence 判据,缺交/不合格硬拒,不登记。
9168
+ const reviewStartCheck = validateStartPhaseEvidence(args?.startPhases)
9169
+ if (!reviewStartCheck.ok) {
9170
+ recordGate('review', false, reviewStartCheck.code ?? 'START_EVIDENCE_INCOMPLETE')
9171
+ return {
9172
+ ok: false,
9173
+ code: reviewStartCheck.code ?? 'START_EVIDENCE_INCOMPLETE',
9174
+ subtaskId,
9175
+ error: `开工证据${reviewStartCheck.code === 'START_EVIDENCE_MISSING' ? '缺失' : '不合格'}:部门负责人执行自己的任务前必须先完成五步前三步(任务梳理 + 资源/工具/方案研究 + 准备就绪),随 review 一并提交 startPhases={ planning{ problemAnalysis[], approach[], approachBasis[], resources[], tools[] }, preparation{ prepared[], evidence[] } }。${reviewStartCheck.error ?? ''}`,
8827
9176
  }
8828
9177
  }
8829
9178
  // [2.5.0][R2×R4] 重新 review 未再配整体等级时,继承行上已持久化的
@@ -8846,13 +9195,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8846
9195
  // [2.5.2][stall-fix] 中断判据快照:本次 review 之前是否已登记整体档。
8847
9196
  const hadEffortOverride = typeof row.effortOverride === 'string' && row.effortOverride.length > 0
8848
9197
  const written = persist({
9198
+ // [3.0.8] 负责人开工证据存行级 startPhases(结算一致性比对读档用)。
9199
+ startPhases: reviewStartCheck.evidence,
8849
9200
  consolidation: {
8850
- problemAnalysis: input.problemAnalysis,
8851
- constraints: input.constraints,
8852
- unknowns: input.unknowns,
8853
- approach: input.approach,
8854
- // [2.5.1] 两轮深度思考协议:第二轮依据随梳理产物留档,dispatch 读回同口径。
8855
- approachBasis: input.approachBasis,
8856
9201
  assignments: input.assignments,
8857
9202
  // [2.5.0] 整体任务等级随梳理产物留档,dispatch 读回时同口径消费。
8858
9203
  ...(preview.taskEffort ? { taskReasoningEffort: preview.taskEffort } : {}),
@@ -8893,7 +9238,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8893
9238
  taskEffort: preview.taskEffort,
8894
9239
  ...(preview.taskEffortClamped ? { taskEffortClamped: preview.taskEffortClamped } : {}),
8895
9240
  model: model ?? '(未知,未施加静态等级约束)',
8896
- hint: '梳理产物已登记(durable,刷新后门禁依然生效)。现在可调用 action="dispatch" 正式派发;每位下级的推理等级已按当前模型家族合法集合钳制(clamped 列出越界修正与原因,留痕可审计)。'
9241
+ hint: '分工表与开工证据已登记(durable,刷新后门禁依然生效)。现在可调用 action="dispatch" 正式派发;每位下级的推理等级已按当前模型家族合法集合钳制(clamped 列出越界修正与原因,留痕可审计)。'
8897
9242
  + (preview.taskEffort ? `整体任务等级已配置为 ${preview.taskEffort}(负责人自配档),本任务重试/续跑全程沿用;下级以 self_effort 自配为权威。` : '未配置整体任务等级:负责人须按先配置后开工经 review 自配(consolidation.taskReasoningEffort);下级经 self_effort 自配。'),
8898
9243
  }
8899
9244
  }
@@ -8938,7 +9283,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8938
9283
  * 旧实现这里直接发全新任务书,叶子失败后重派只能整步重跑。
8939
9284
  */
8940
9285
  const priorDelegates = Array.isArray(row.delegates) ? row.delegates : []
8941
- const consolidationApproach = Array.isArray((row.consolidation as any)?.approach) ? (row.consolidation as any).approach : []
9286
+ // [3.0.8] retry brief 的负责人执行蓝图改从行级 startPhases.planning.approach
9287
+ // 读取(consolidation 不再携带两轮思考产物)。
9288
+ const consolidationApproach = Array.isArray((row as any)?.startPhases?.planning?.approach) ? (row as any).startPhases.planning.approach : []
8942
9289
  for (const assignment of delegationPlan.members) {
8943
9290
  const rulesBrief = buildLlmRulesBrief({
8944
9291
  model,
@@ -8960,12 +9307,12 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8960
9307
  const priorSelf = typeof stashedSelf === 'string' && stashedSelf ? stashedSelf
8961
9308
  : (typeof prior?.selfEffort === 'string' && prior.selfEffort ? prior.selfEffort : '')
8962
9309
  /*
8963
- * [2.5.2] 执行前两轮思考读档:已登记思考产物(delegateDeepThinks 或
8964
- * delegates[].deepThink)⇒ 随接续提示词下发执行蓝图,直接 phase-1;
8965
- * 未登记(含旧计划遗留叶子)⇒ 仍走 phase-0 补齐思考+自配后才准执行。
9310
+ * [3.0.8] 开工证据读档:已登记证据(delegateStartPhases 或
9311
+ * delegates[].startPhases)⇒ 随接续提示词下发执行蓝图,直接 phase-1;
9312
+ * 未登记(含旧计划遗留叶子)⇒ 仍走 phase-0 补齐证据+自配后才准执行。
8966
9313
  */
8967
- const stashedThink = sanitizeMainDeepThink((row.delegateDeepThinks as any)?.[assignment.member])
8968
- ?? sanitizeMainDeepThink(prior?.deepThink)
9314
+ const stashedStartPhases = sanitizeStartPhaseEvidence((row.delegateStartPhases as any)?.[assignment.member])
9315
+ ?? sanitizeStartPhaseEvidence(prior?.startPhases)
8969
9316
  /*
8970
9317
  * [T6][D9][契约v1 §5] 预估读档门禁:已登记且已送达(delivery='sent')的预估
8971
9318
  * 才算门禁通过。未预估、或预估投递失败(failed)⇒ 回 phase-0 补交完整原子对
@@ -8976,9 +9323,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8976
9323
  const stashedEstimate = sanitizeLeafEstimate((row.delegateEstimates as any)?.[assignment.member])
8977
9324
  ?? sanitizeLeafEstimate(prior?.estimate)
8978
9325
  const registeredEstimate = stashedEstimate?.delivery === 'sent' ? stashedEstimate : null
8979
- const leafPhaseZero = !priorSelf || !stashedThink || !registeredEstimate
8980
- const selfContinuation = priorSelf && stashedThink && registeredEstimate
8981
- ? `【自配档接续·两轮思考读档】你的自配推理等级 \`${priorSelf}\` 与执行前两轮深度思考产物均已登记生效(成员自配为权威)。继续勿重做:直接执行正式任务,不要重新评估复杂度、不要重复提交思考产物。正式执行必须严格按你第二轮理清的方法、流程、步骤进行(你的第一轮产物:${stashedThink.problemAnalysis.join(';').slice(0, 200)}…;你的第二轮产物:${stashedThink.approach.join(';').slice(0, 300)}…),全程少走弯路:先查历史教训、先验证再动手、不重复试错。你的开工预估已登记并送达部门负责人(约 ${registeredEstimate.declaredMinutes} 分钟,整数分钟),无需重复上报。`
9326
+ const leafPhaseZero = !priorSelf || !stashedStartPhases || !registeredEstimate
9327
+ const selfContinuation = priorSelf && stashedStartPhases && registeredEstimate
9328
+ ? `【自配档接续·开工证据读档】你的自配推理等级 \`${priorSelf}\` 与五步第 1/2/3 步开工证据均已登记生效(成员自配为权威)。继续勿重做:直接执行正式任务,不要重新评估复杂度、不要重复提交开工证据。正式执行必须严格按你第二步理清的方法、流程、步骤进行(你的第一步产物:${stashedStartPhases.planning.problemAnalysis.join(';').slice(0, 200)}…;你的第二步产物:${stashedStartPhases.planning.approach.join(';').slice(0, 300)}…),全程少走弯路:先查历史教训、先验证再动手、不重复试错。你的开工预估已登记并送达部门负责人(约 ${registeredEstimate.declaredMinutes} 分钟,整数分钟),无需重复上报。`
8982
9329
  : (priorSelf
8983
9330
  ? `【自配档接续】你的自配推理等级 \`${priorSelf}\` 已登记生效(成员自配为权威)。继续勿重做:直接执行正式任务,不要重新评估复杂度。`
8984
9331
  : '')
@@ -9004,7 +9351,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9004
9351
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(scope=计划根会话)。
9005
9352
  notifyDepthOverrideConflict(ctx, typeof parentSession?.header?.parentSession === 'string' ? parentSession.header.parentSession : (typeof parentId === 'string' ? parentId : null))
9006
9353
  // [2.5.5][治本] 同 executeSubtask:spec 顶层契约(prompt/parent/cwd/agentOptions/maxDepth)。
9007
- const activation = await ctx.subagents.startActivation({
9354
+ const activation = await startActivationQueued<any>(
9355
+ () => ctx.subagents.startActivation({
9008
9356
  provider: 'spawn',
9009
9357
  label: `${row.department}:${subtaskId}→${assignment.member}`.slice(0, 120),
9010
9358
  prompt: [{ type: 'text', text: promptText }],
@@ -9021,7 +9369,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9021
9369
  maxDepth: 2,
9022
9370
  signal,
9023
9371
  delivery: 'caller',
9024
- })
9372
+ }),
9373
+ signal,
9374
+ `派发成员 ${assignment.member}(${subtaskId})`,
9375
+ )
9025
9376
  childId = typeof activation?.childId === 'string' ? activation.childId : null
9026
9377
  if (activation && typeof activation.result?.then === 'function') {
9027
9378
  const settledChildId = childId
@@ -9108,7 +9459,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9108
9459
  taskEffort: delegationPlan.taskEffort,
9109
9460
  effortOverride: written?.effortOverride ?? row.effortOverride ?? null,
9110
9461
  ...(rejected.length ? { rejected: rejected.map((item) => ({ member: item.member, error: item.error })) } : {}),
9111
- hint: '第三层已派发(一层下级、叶子层,第四层会被硬拒)。每位全球顶尖专家的完成结论会送回本会话(delivery=caller);收齐后由你汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」(delegates[].closure=escalated):必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。',
9462
+ hint: '第三层已派发(一层下级、叶子层,第四层会被硬拒)。每位全球顶尖专家的完成结论会送回本会话(delivery=caller);收齐后由你汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」(delegates[].closure=escalated):必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。3.0.5 硬规则:任何成员待指示期间,review/dispatch/direct 一律拒绝改派,必须由原成员继续执行。',
9112
9463
  }
9113
9464
  }
9114
9465
 
@@ -9204,7 +9555,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9204
9555
  * [3.0.1] 认可闸门硬门禁:被按住(keyword/manual)且未派发的计划,派发一律
9205
9556
  * 拒绝——这是「未经用户认可不得开跑」的执行侧;唯一的合法出口是
9206
9557
  * dsh_workplan_release(它登记用户认可留痕后解除闸门并派发)。
9207
- * 落点在终态闸门之后、deepThink 门禁之前:拒绝不产生副作用。
9558
+ * 落点在终态闸门之后、开工证据门禁之前:拒绝不产生副作用。
9208
9559
  */
9209
9560
  if (isDispatchHeld(record)) {
9210
9561
  const snapshot = derivePlanSnapshot(record.statuses)
@@ -9219,26 +9570,27 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9219
9570
  stats: snapshot.stats,
9220
9571
  code: 'DISPATCH_HELD',
9221
9572
  error: `计划处于认可闸门之下(${truncate(String(record.dispatchHold?.reason ?? '未注明原因'), 200)}):任务要求先经用户认可再执行,在用户明确认可前不得派发。`,
9222
- hint: '请先征得用户明确认可,然后调用 dsh_workplan_release(可附 note 留痕、附 deepThink 直接开跑);不要用 dsh_workplan_dispatch 绕过闸门。',
9573
+ hint: '请先征得用户明确认可,然后调用 dsh_workplan_release(可附 note 留痕、附 startPhases 直接开跑);不要用 dsh_workplan_dispatch 绕过闸门。',
9223
9574
  }
9224
9575
  }
9225
9576
  /*
9226
- * [2.5.1] 主 Agent 两轮深度思考协议硬门禁(用户 2026-11-11 补充要求)。
9577
+ * [3.0.8] 主 Agent 开工证据硬门禁(五步工作法单框架;取代 2.5.1 两轮深度思考
9578
+ * deepThink 门禁——两轮内容本就是五步第 1、2 步的子集,同一内容不再双份提交)。
9227
9579
  *
9228
- * 主 Agent 执行自己的任务同样必须:先全面、全盘、深入梳理、研究、思考
9229
- * 自己的任务(第一轮),再基于第一轮完成好的所有结果再全面、全盘、深入
9230
- * 地开展梳理、研究和思考,理清方法、流程和步骤(第二轮),最后才基于
9231
- * 第二轮的方法、流程、步骤开始具体执行——派发就是主 Agent 执行的起点,
9232
- * 因此首次派发必须随附 deepThink 产物,未交/不合格硬拒,提示词绕不过。
9580
+ * 主 Agent 执行自己的任务同样必须先完成五步前三步:第一步全面、全盘、深入
9581
+ * 梳理、研究、思考自己的任务;第二步基于第一步完成好的所有结果研究资源、
9582
+ * 工具与具体实施方案;第三步把资源与工具真正备齐并给出就绪证据——派发就是
9583
+ * 主 Agent 执行的起点,因此首次派发必须随附 startPhases 证据,未交/不合格
9584
+ * 硬拒(START_EVIDENCE_MISSING / START_EVIDENCE_INCOMPLETE),提示词绕不过。
9233
9585
  *
9234
9586
  * 落点=已通过 NO_PLAN / PLAN_ID_MISMATCH / 终态闸门之后、派发预告与任何
9235
9587
  * 子 Agent 启动之前:拒绝不产生副作用,也不刷派发预告。登记后持久化
9236
9588
  * (record + durable workplan-update),续跑/重试/join/重启回放读档放行;
9237
- * 产物按 planId 记账——重规划换新计划是新任务,必须重新两轮思考。
9589
+ * 证据按 planId 记账——重规划换新计划是新任务,必须重新完成前三步。
9238
9590
  */
9239
- if (!record.mainDeepThink || record.mainDeepThinkPlanId !== record.plan.planId) {
9240
- const deepThinkCheck = validateMainDeepThink(args?.deepThink)
9241
- if (!deepThinkCheck.ok) {
9591
+ if (!record.mainStartPhases || record.mainStartPhasesPlanId !== record.plan.planId) {
9592
+ const startCheck = validateStartPhaseEvidence(args?.startPhases)
9593
+ if (!startCheck.ok) {
9242
9594
  const snapshot = derivePlanSnapshot(record.statuses)
9243
9595
  return {
9244
9596
  ok: false,
@@ -9249,19 +9601,19 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9249
9601
  complete: false,
9250
9602
  remaining: Math.max(0, Number(snapshot.stats.total ?? 0) - Number(snapshot.stats.done ?? 0)),
9251
9603
  stats: snapshot.stats,
9252
- code: deepThinkCheck.code,
9253
- error: deepThinkCheck.error,
9254
- hint: '先完成两轮深度思考再派发:第一轮全面、全盘、深入梳理研究思考自己的任务,第二轮基于第一轮全部结果理清方法、流程、步骤(含依据 approachBasis),随 dsh_workplan_dispatch 的 deepThink 参数提交;登记后续跑/重启自动读档,无需重复提交。',
9604
+ code: startCheck.code,
9605
+ error: startCheck.error,
9606
+ hint: '先完成五步前三步再派发:第一步任务梳理,第二步基于第一步全部结果研究资源、工具与具体实施方案(含依据 approachBasis),第三步准备就绪,随 dsh_workplan_dispatch 的 startPhases 参数提交;登记后续跑/重启自动读档,无需重复提交。',
9255
9607
  }
9256
9608
  }
9257
- record.mainDeepThink = deepThinkCheck.deepThink
9258
- record.mainDeepThinkPlanId = record.plan.planId
9609
+ record.mainStartPhases = startCheck.evidence
9610
+ record.mainStartPhasesPlanId = record.plan.planId
9259
9611
  // durable 持久化(计划级字段,subtaskId=null 不落任何子任务行);回放消费端同口径消毒。
9260
9612
  appendUserMessage(session, buildUpdateMessage({
9261
9613
  planId: record.plan.planId,
9262
9614
  subtaskId: null,
9263
- mainDeepThink: deepThinkCheck.deepThink,
9264
- mainDeepThinkPlanId: record.plan.planId,
9615
+ mainStartPhases: startCheck.evidence,
9616
+ mainStartPhasesPlanId: record.plan.planId,
9265
9617
  }))
9266
9618
  }
9267
9619
  /*
@@ -9389,6 +9741,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9389
9741
  onSubtaskDone: (recordArg: any, subtask: any, verdict: any) =>
9390
9742
  emitSubtaskDoneNotice(recordArg, session, subtask, verdict),
9391
9743
  }
9744
+ // [3.0.6][第 3 批①] 人工派发/续派复用原 record:派发前清零等待耗尽标记(同 startAutoDispatch)。
9745
+ record.turnWaitExhausted = undefined
9746
+ record.waitExhaustedNotifiedTurn = undefined
9392
9747
  record.dispatchPromise = dispatchPlan(ctx, record, {
9393
9748
  ...roundOptions,
9394
9749
  signal: dispatchController.signal,
@@ -9487,6 +9842,40 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9487
9842
  */
9488
9843
  const STOP_STEER_LIMIT = 2
9489
9844
 
9845
+ /*
9846
+ * [3.0.6][第 3 批①] 收尾等待上限(解析一次,全路径同值)。
9847
+ * ≤0 = 无限等待(旧行为);默认 60 分钟。只约束 turn-stopping 的等待,
9848
+ * 不构成部门/专家的执行时限。
9849
+ */
9850
+ const turnStoppingMaxWaitMs = (() => {
9851
+ const raw = Number(options.turnStoppingMaxWaitMs)
9852
+ return Number.isFinite(raw) && raw > 0 ? raw : 0
9853
+ })()
9854
+
9855
+ /**
9856
+ * 带上限地等待一个收尾承诺。capMs<=0 时等同无限等待(旧行为)。
9857
+ * 返回 true = 按时结算;false = 等满上限(调用方决定如何收尾)。
9858
+ * 承诺自身结算后绝不再被本函数消费——由调用方一次性判定。
9859
+ */
9860
+ async function waitTurnPromise(promise: Promise<any>, capMs: number): Promise<boolean> {
9861
+ if (!(capMs > 0)) {
9862
+ try { await promise } catch { /* 结算失败已由产出方留痕 */ }
9863
+ return true
9864
+ }
9865
+ let timer: any = null
9866
+ try {
9867
+ const timeout = new Promise<'timeout'>((resolve) => {
9868
+ // 收束类计时器:到点即状态转移(等待预算耗尽),禁止 unref
9869
+ // (handle-policy 契约;到点必然被 clearTimeout 或先行触发)。
9870
+ timer = setTimeout(() => resolve('timeout'), capMs)
9871
+ })
9872
+ const outcome = await Promise.race([promise.then(() => 'settled' as const, () => 'settled' as const), timeout])
9873
+ return outcome === 'settled'
9874
+ } finally {
9875
+ if (timer) clearTimeout(timer)
9876
+ }
9877
+ }
9878
+
9490
9879
  function recordReadiness(record: any) {
9491
9880
  return readinessOf(record)
9492
9881
  }
@@ -9539,9 +9928,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9539
9928
  /**
9540
9929
  * [3.0.1] 解除认可闸门并立即派发。release 是「用户已明确认可」的唯一合法
9541
9930
  * 出口:它把按住事实追加进 gateHistory(只增审计,durable 回放),清空
9542
- * dispatchHold,然后走 dispatchTool 的同一套闸门(终态/deepThink 等照常生效)。
9543
- * 若 dispatch 因 deepThink 等门禁被拒,闸门保持已解除——认可事实是用户给的,
9544
- * 不让它人质化;补齐 deepThink 后直接重发 dispatch 即可。
9931
+ * dispatchHold,然后走 dispatchTool 的同一套闸门(终态/开工证据等照常生效)。
9932
+ * 若 dispatch 因开工证据等门禁被拒,闸门保持已解除——认可事实是用户给的,
9933
+ * 不让它人质化;补齐 startPhases 后直接重发 dispatch 即可。
9545
9934
  */
9546
9935
  async function releaseTool(agent: any, args: any, signal: any) {
9547
9936
  const session = agent?.session
@@ -9583,7 +9972,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9583
9972
  }
9584
9973
  const dispatched = await dispatchTool(agent, {
9585
9974
  planId: record.plan.planId,
9586
- deepThink: args?.deepThink,
9975
+ startPhases: args?.startPhases,
9587
9976
  mode: args?.mode,
9588
9977
  }, signal)
9589
9978
  return { ok: dispatched?.ok !== false, gateReleased: true, hold, note, dispatch: dispatched }
@@ -9797,6 +10186,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9797
10186
  * pre-step;若只在那里 supersede,旧规划仍会跑完并迟到交付。官方
9798
10187
  * `agent/inbox/inserted` 在消息进入 live inbox 时即发本事件,因此这里先中止。
9799
10188
  * 内部 workplan 通知、社交/状态/空泛续跑均不取消;同任务重复投递保持幂等。
10189
+ * [T3][M2 取代显式通知] 与 pre-step 取代路径同一缺口:此处只置 superseded +
10190
+ * abort,全程静默,用户看到的就是"任务没分配"且无任何解释。这里补同一条
10191
+ * 用户可见取代通知;alreadySuperseded 守卫保证连续多条新消息只通知一次(幂等),
10192
+ * 且绝不恢复旧计划、绝不写 state.records,避免迟到覆盖新任务占位记录。
9800
10193
  */
9801
10194
  function onInboxInserted(payload: any) {
9802
10195
  const session = payload?.agent?.session
@@ -9806,10 +10199,18 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9806
10199
  const message = payload?.message
9807
10200
  if (humanMessages([message]).length === 0) return
9808
10201
  const taskText = taskTextFromMessages([message])
9809
- if (!taskText || isSocialMessage(taskText) || isVagueContinuation(taskText) || isStatusQuestion(taskText)) return
10202
+ // [3.0.7] 确认回复不取代在途后台规划:它会被 pre-step 标记为 userConfirmed,
10203
+ // 计划落地即自动放行派发;此处若不排除,确认消息会先把原规划中止掉。
10204
+ if (!taskText || isSocialMessage(taskText) || isVagueContinuation(taskText) || isStatusQuestion(taskText) || isUserConfirmation(taskText)) return
9810
10205
  if (planning.taskText === taskText) return
10206
+ const alreadySuperseded = planning.superseded === true
9811
10207
  planning.superseded = true
9812
10208
  planning.controller.abort()
10209
+ if (!alreadySuperseded) {
10210
+ appendUserMessage(session,
10211
+ '【dsh-workplan·任务分解被取代】你上一条任务的后台自动分解已被本条新消息中止,原任务不会自动分配。\n' +
10212
+ '如仍需执行原任务:请重新发送该任务,或说"重新生成计划并执行";也可以让我先手动制定计划给你确认后再执行。')
10213
+ }
9813
10214
  }
9814
10215
 
9815
10216
  async function onTurnStopping(payload: any) {
@@ -9833,8 +10234,21 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9833
10234
  */
9834
10235
  let record = state.records.get(session.id) ?? known
9835
10236
  const planning = state.planningInFlight?.get(session.id)
9836
- if (planning?.promise) {
9837
- try { await planning.promise } catch { /* 后台规划自身已记录降级/错误 */ }
10237
+ if (planning?.promise && planning.turnWaitTimedOut !== true) {
10238
+ /*
10239
+ * [3.0.6][第 3 批①] 收尾等待上限:规划在途时最多等
10240
+ * turnStoppingMaxWaitMs(默认 60 分钟;0=无限)。到点不再等,标记
10241
+ * turnWaitTimedOut(同一规划对象只等一次,后续收尾不再重复等待),
10242
+ * 按规划未完成继续走下方既有闸门(有界 steer / fail-closed)。
10243
+ */
10244
+ const settled = await waitTurnPromise(planning.promise, turnStoppingMaxWaitMs)
10245
+ if (!settled) {
10246
+ planning.turnWaitTimedOut = true
10247
+ ctx.logger?.warn?.(
10248
+ `dsh-workplan: 回合 ${turn} 等待在途规划达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟,`
10249
+ + '按「等待预算耗尽」继续收尾检查(规划仍在后台,完成后的交回逻辑不受影响)',
10250
+ )
10251
+ }
9838
10252
  /*
9839
10253
  * 等待期间若同回合后续 step 已用新任务取代旧规划,本次旧收尾必须退出;
9840
10254
  * 新规划的收尾会自行等待并交回,绝不能在这里消费旧结果或误 steer。
@@ -9866,12 +10280,77 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9866
10280
  if (isPlanModeActive(ctx, session)) return
9867
10281
  if (!stopGateApplies(record, session, turn)) return
9868
10282
  if (record.dispatchPromise) {
9869
- try {
9870
- await record.dispatchPromise
9871
- } catch {
9872
- /* the failure is already on record.errors; the gate only needs the outcome */
10283
+ if (record.turnWaitExhausted) {
10284
+ /*
10285
+ * [3.0.6][第 3 批①] 本轮(及后续回合)已耗尽过等待预算且派发仍在跑:
10286
+ * 不再重复等待,直接走下方「放行但留痕」分支,回合如实收尾。
10287
+ */
10288
+ } else {
10289
+ const settled = await waitTurnPromise(record.dispatchPromise, turnStoppingMaxWaitMs)
10290
+ if (!settled) {
10291
+ record.turnWaitExhausted = { turn, at: Date.now(), waitedMs: turnStoppingMaxWaitMs }
10292
+ record.errors = [...(record.errors ?? []), `回合收尾等待派发达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟(等待预算耗尽,派发仍在后台执行)`].slice(-20)
10293
+ ctx.logger?.warn?.(
10294
+ `dsh-workplan: 回合 ${turn} 等待派发达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟:`
10295
+ + `计划 ${record.plan?.planId} 仍在后台执行,结果消息会照常落盘`,
10296
+ )
10297
+ if (failClosedActive) {
10298
+ throw new PlanError(
10299
+ `等待预算耗尽:回合收尾已连续等待派发超过 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟`
10300
+ + `(计划 ${record.plan?.planId} 仍在后台执行,本回合不再等待)。headless 以非零退出码结束,不输出「已完成」结果。`,
10301
+ 'WORKPLAN_WAIT_EXHAUSTED',
10302
+ { planId: record.plan?.planId },
10303
+ )
10304
+ }
10305
+ }
10306
+ }
10307
+ if (!record.turnWaitExhausted) {
10308
+ try {
10309
+ await record.dispatchPromise
10310
+ } catch {
10311
+ /* the failure is already on record.errors; the gate only needs the outcome */
10312
+ }
10313
+ finishRound(record, session)
10314
+ }
10315
+ if (record.turnWaitExhausted) {
10316
+ /*
10317
+ * 等待预算耗尽的放行与 steer 用尽同一套「放行但留痕」语义:
10318
+ * 不 steer(避免再拖住回合)、记 releasedIncomplete、追加 notice。
10319
+ * fail-closed 已在上方抛错,不会走到这里。
10320
+ */
10321
+ const stuck = derivePlanSnapshot(record.statuses)
10322
+ const released = (stuck.statuses ?? [])
10323
+ .filter((item: any) => item.status !== 'done')
10324
+ .map((item: any) => String(item.subtaskId))
10325
+ record.releasedIncomplete = {
10326
+ turn,
10327
+ at: Date.now(),
10328
+ done: stuck.stats.done,
10329
+ total: stuck.stats.total,
10330
+ remaining: released,
10331
+ reason: 'wait-exhausted',
10332
+ }
10333
+ try {
10334
+ if (record.waitExhaustedNotifiedTurn !== turn) {
10335
+ record.waitExhaustedNotifiedTurn = turn
10336
+ appendUserMessage(session, makeUserMessage(
10337
+ [
10338
+ `⏳ 本轮等待派发已达上限(${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟),按计划仍在后台执行,本回合先行收尾(计划 ${record.plan.planId})`,
10339
+ `进度 ${stuck.stats.done}/${stuck.stats.total};未完成:${released.join(', ') || '无'}`,
10340
+ '后台结果照常落盘:稍后可用 dsh_workplan_status 查看,或在下一回合继续。',
10341
+ ].join('\n'),
10342
+ {
10343
+ kind: 'workplan-release',
10344
+ form: 'notice',
10345
+ summary: `等待预算耗尽放行 ${stuck.stats.done}/${stuck.stats.total}`,
10346
+ },
10347
+ ))
10348
+ }
10349
+ } catch (error) {
10350
+ ctx.logger?.warn?.(`dsh-workplan: 等待耗尽放行留痕写入失败:${error instanceof Error ? error.message : String(error)}`)
10351
+ }
10352
+ return
9873
10353
  }
9874
- finishRound(record, session)
9875
10354
  if (!stopGateApplies(record, session, turn)) return
9876
10355
  }
9877
10356
  const book = record.stopSteers && record.stopSteers.turn === turn
@@ -9980,8 +10459,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9980
10459
  /*
9981
10460
  * [1.12.3] fail-closed 的硬失败必须穿过这层日志包装:
9982
10461
  * 这里原本把任何异常降级成一条 warn,等于把上面的抛错又吃掉。
10462
+ * [3.0.6] WORKPLAN_WAIT_EXHAUSTED 同属硬失败(等待预算耗尽),同样必须穿透。
9983
10463
  */
9984
- if (error instanceof PlanError && error.code === 'WORKPLAN_INCOMPLETE') throw error
10464
+ if (error instanceof PlanError
10465
+ && (error.code === 'WORKPLAN_INCOMPLETE' || error.code === 'WORKPLAN_WAIT_EXHAUSTED')) throw error
9985
10466
  ctx.logger?.warn?.(`dsh-workplan: 回合收尾检查失败:${error instanceof Error ? error.message : String(error)}`)
9986
10467
  }
9987
10468
  }
@@ -10482,8 +10963,17 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
10482
10963
  async function route(req: any, res: any, connectionCtx: any = ctx) {
10483
10964
  applyHardeningHeaders(res)
10484
10965
  let rejection
10966
+ /*
10967
+ * 鉴权 fail-closed:connection 服务存在但没有 requestRejection(宿主 API 改名/降级)时,
10968
+ * 旧实现会因可选链返回 undefined 而直接放行,等于把全部会话计划暴露给未鉴权请求。
10969
+ * 看板是敏感数据路由,宁可直接拒绝,也不能在“检查器不见了”时默认通过。
10970
+ */
10971
+ if (typeof connectionCtx?.connection?.requestRejection !== 'function') {
10972
+ respondJson(res, 503, { ok: false, error: '鉴权服务不可用,已拒绝访问' })
10973
+ return
10974
+ }
10485
10975
  try {
10486
- rejection = await Promise.resolve(connectionCtx?.connection?.requestRejection?.(req))
10976
+ rejection = await Promise.resolve(connectionCtx.connection.requestRejection(req))
10487
10977
  } catch {
10488
10978
  respondJson(res, 403, { ok: false, error: '未授权的请求' })
10489
10979
  return
@@ -10512,11 +11002,11 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
10512
11002
  return
10513
11003
  }
10514
11004
  try {
10515
- const payload = plansPayload(url.searchParams.get('sessionId') ?? undefined)
10516
- const body = JSON.stringify(payload)
10517
- if (body.length > 2_500_000) {
10518
- respondJson(res, 200, { ...payload, truncated: true, sessions: payload.sessions.slice(0, 12) })
10519
- return
11005
+ let payload: any = plansPayload(url.searchParams.get('sessionId') ?? undefined)
11006
+ let body = JSON.stringify(payload)
11007
+ if (Buffer.byteLength(body) > MAX_PLANS_RESPONSE_BYTES) {
11008
+ payload = trimPlansPayload(payload)
11009
+ body = JSON.stringify(payload)
10520
11010
  }
10521
11011
  if (req.method === 'HEAD') {
10522
11012
  res.writeHead(200, {
@@ -10544,10 +11034,20 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
10544
11034
  /**
10545
11035
  * [2.0.0] 只读的「永久教训记忆」入口。
10546
11036
  *
10547
- * 用户要求这些经验必须能被复核。主 Agent 在阶段三可以用它查:记住了什么、
11037
+ * 用户要求这些经验必须能被复核。主 Agent 在第四步可以用它查:记住了什么、
10548
11038
  * 哪些同类错误在重复发生、文件到底写在哪。它只读文件,不改任何计划状态。
10549
11039
  */
10550
- async function lessonsTool(_agent: any, args: any) {
11040
+ /*
11041
+ * [3.0.6][复审修复] 数据面越权:lessons.jsonl 是跨项目的全局永久记忆(含
11042
+ * 其它项目 cwd 与问题描述),此前无任何会话校验,任意子 Agent(含其它插件
11043
+ * 拉起的子会话)都能读走。这里与其它工具(update/replan/cancel 等)同一
11044
+ * 写法加 isRootSession 硬校验:非根会话直接抛权限错误,不依赖提示词约束;
11045
+ * 根会话行为不变。
11046
+ */
11047
+ async function lessonsTool(agent: any, args: any) {
11048
+ const session = agent?.session
11049
+ if (!session) throw new PlanError('只能在会话内查询永久教训记忆', 'NO_SESSION')
11050
+ if (!isRootSession(session)) throw new PlanError('子 Agent 不能读取全局永久教训记忆', 'NOT_ROOT')
10551
11051
  const parsed = isRecord(args) ? args : {}
10552
11052
  const action = String(parsed.action ?? 'list')
10553
11053
  const file = resolveLessonsFile()
@@ -10701,6 +11201,80 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
10701
11201
  if (isSocialMessage(taskText)) return downstream
10702
11202
  if (isVagueContinuation(taskText)) return downstream
10703
11203
  if (isStatusQuestion(taskText)) return downstream
11204
+ /*
11205
+ * [3.0.7] 确认回复路由(用户想法,原话):「收到用户确认回复后,你应该结合所
11206
+ * 有上下文全面、深入分析、思考、研究后,开始依据得出的所有结果分配任务」。
11207
+ * 用户 2026-11-18 补充裁决:「用户确认后,无论任务是否已经生成,都必须结合
11208
+ * 所有上下文和用户的回复,全面、深入开展分析、思考、研究,然后依据得出的
11209
+ * 所有结果开始分配任务」——分析在先、派发现在,插件不得在钩子层不经分析
11210
+ * 机械开跑。落到三条出口,全部在 activeTurns 标记与取代/取消逻辑之前:
11211
+ * ① 已有已提交未派发的计划(被认可闸门按住或 plan-first 未派发)→ 解除
11212
+ * 闸门(留痕 gateHistory,记下用户确认原文)、刷新 conversationContext
11213
+ * (含确认消息的全量上下文),并给主 Agent 下分析-派发指令;本回合标记
11214
+ * activeTurns:主 Agent 若未在回合内派发,收尾闸门会拦停 steer「请派发」
11215
+ * 作为兜底,绝不留下「确认后无人派发」的尾巴;
11216
+ * ② 任务分解正在后台进行 → 只标记 userConfirmed,原分解不被取代中止。后台
11217
+ * 分解本身就是「结合所有上下文的深入分析研究」,计划一生成即跳过认可
11218
+ * 闸门、刷新上下文后自动派发(=依据分析得出的结果分配任务);
11219
+ * ③ 其余(无计划/已在执行/终态)→ 交还主 Agent 结合上下文正常答复,绝不做
11220
+ * 任务分解——确认消息不再是新任务。
11221
+ */
11222
+ if (isUserConfirmation(taskText)) {
11223
+ if (existing?.plan && !existing.dispatchedAt && !isTerminalPhase(existing.phase)
11224
+ && !existing.dispatchPromise && existing.phase !== 'executing' && !existing.degraded
11225
+ && existing.planner?.outcome !== 'SALVAGED') {
11226
+ if (planMode) return downstream
11227
+ const wasHeld = isDispatchHeld(existing)
11228
+ if (wasHeld) {
11229
+ const hold = existing.dispatchHold
11230
+ existing.dispatchHold = null
11231
+ existing.gateHistory = [
11232
+ ...(Array.isArray(existing.gateHistory) ? existing.gateHistory : []),
11233
+ { hold, releasedAt: Date.now(), note: `用户确认消息自动放行:${truncate(taskText, 60)}`, by: 'user' },
11234
+ ].slice(-10)
11235
+ }
11236
+ existing.conversationContext = recentConversation(session)
11237
+ existing.updatedAt = Date.now()
11238
+ try {
11239
+ appendUserMessage(session, buildUpdateMessage({
11240
+ planId: existing.plan.planId,
11241
+ subtaskId: null,
11242
+ status: existing.phase,
11243
+ ...(wasHeld ? { dispatchHold: null, gateHistory: existing.gateHistory } : {}),
11244
+ }))
11245
+ appendUserMessage(session, makeUserMessage(
11246
+ [
11247
+ `✅ 已收到并采纳您的确认回复("${truncate(taskText, 40)}"):${wasHeld ? '认可闸门已按您的确认解除。' : ''}`,
11248
+ '【主 Agent 指令·必须执行】您必须结合当前所有上下文和用户的这条确认回复,全面、深入地开展分析、思考、研究;然后依据得出的所有结果,调用 dsh_workplan_dispatch 开始分配任务(dispatch 时必须提交 startPhases,即您刚才的完整分析——五步第 1/2/3 步开工证据,它会作为登记在案的分析依据)。',
11249
+ '若分析发现计划需要按用户意图调整:先调用 dsh_workplan_replan 调整,再派发调整后的计划。',
11250
+ '禁止:不分析直接派发;把计划重新按住;把本条确认当成新任务重新分解。',
11251
+ ].join('\n'),
11252
+ { kind: 'workplan-confirm-analyze', form: 'notice', summary: '用户已确认:请深入分析后调用 workplan_dispatch 派发' },
11253
+ ))
11254
+ } catch (error) {
11255
+ pushRecordError(existing, error)
11256
+ }
11257
+ if (!state.activeTurns) state.activeTurns = new Map()
11258
+ state.activeTurns.set(session.id, Number(payload.turn ?? 0))
11259
+ return downstream
11260
+ }
11261
+ const planning = state.planningInFlight?.get(session.id)
11262
+ if (planning && planning.superseded !== true) {
11263
+ if (planning.userConfirmed !== true) {
11264
+ planning.userConfirmed = true
11265
+ try {
11266
+ appendUserMessage(session, makeUserMessage(
11267
+ '✅ 已收到您的确认回复:原计划的后台分解不会被本条消息取代;任务分解完成后将自动放行并派发,无需再次确认。',
11268
+ { kind: 'workplan-confirm-received', form: 'notice', summary: '确认已接收:计划生成后将自动派发' },
11269
+ ))
11270
+ } catch (error) {
11271
+ pushRecordError(state.records.get(session.id) ?? {}, error)
11272
+ }
11273
+ }
11274
+ return downstream
11275
+ }
11276
+ return downstream
11277
+ }
10704
11278
  /*
10705
11279
  * [1.8.7] Remember that this turn carries a real task.
10706
11280
  *
@@ -10719,8 +11293,21 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
10719
11293
  const priorPlanning = state.planningInFlight?.get(session.id)
10720
11294
  if (priorPlanning) {
10721
11295
  if (priorPlanning.taskText === taskText) return downstream
11296
+ /*
11297
+ * [T3][M2 取代显式通知] 原任务的后台自动分解被本条新消息取代。T1 根因:此处置旧规划
11298
+ * 只置 superseded + abort,全程静默,用户看到的就是"任务没分配"且无任何解释。这里补一条
11299
+ * 用户可见降级通知。边界沿用 11099 注释的防御意图:绝不恢复旧计划、绝不写 state.records
11300
+ * (避免迟到覆盖新任务占位记录);通知只走 appendUserMessage(与规划预告/心跳同一合规
11301
+ * 写入器)。alreadySuperseded 守卫保证连续多条新消息只在首次取代时通知一次(幂等)。
11302
+ */
11303
+ const alreadySuperseded = priorPlanning.superseded === true
10722
11304
  priorPlanning.superseded = true
10723
11305
  priorPlanning.controller.abort()
11306
+ if (!alreadySuperseded) {
11307
+ appendUserMessage(session,
11308
+ '【dsh-workplan·任务分解被取代】你上一条任务的后台自动分解已被本条新消息中止,原任务不会自动分配。\n' +
11309
+ '如仍需执行原任务:请重新发送该任务,或说"重新生成计划并执行";也可以让我先手动制定计划给你确认后再执行。')
11310
+ }
10724
11311
  }
10725
11312
  const conversationContext = recentConversation(session)
10726
11313
  if (existing?.plan?.createdTurn === payload.turn) return downstream
@@ -11124,8 +11711,11 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
11124
11711
  * [3.0.1] 认可闸门:任务锚点命中「先经用户认可再执行」门槛语时,计划照出、
11125
11712
  * 按住不派(dispatchHold 落档),直到用户明确认可、主 Agent 调用
11126
11713
  * dsh_workplan_release。必须在 record 字面量之前声明——字面量引用了它。
11714
+ *
11715
+ * [3.0.7] 例外:分解期间用户已回过确认(planningEntry.userConfirmed)——
11716
+ * 认可事实先于计划成立,闸门不再按住,计划落地即自动放行派发。
11127
11717
  */
11128
- const approvalHeld = !planMode && approvalGateVerdict.held
11718
+ const approvalHeld = !planMode && approvalGateVerdict.held && planningEntry.userConfirmed !== true
11129
11719
  const fullPlan = attachPlanMeta(plan, {
11130
11720
  planId,
11131
11721
  sessionId: session.id,
@@ -11174,7 +11764,17 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
11174
11764
  * 「先经用户认可再执行」门槛语时同样不自动派发——用户明确认可、主 Agent
11175
11765
  * 调用 dsh_workplan_release 之前,计划只展示、任何派发都被拒。
11176
11766
  */
11177
- const autoDispatched = !planMode && !approvalHeld && options?.autoDispatch !== false
11767
+ /*
11768
+ * [3.0.6][复审修复] SALVAGED 计划禁止自动派发:规划器抢救出的残缺计划
11769
+ * (超时/中断截断、仅过部分校验)未经确认直接 startAutoDispatch,等于让
11770
+ * 残缺的部门划分与验收口径在无人复核的情况下生效。这里把 outcome 纳入
11771
+ * 派发判据,SALVAGED 时改为下发一条用户可见通知(见下方 deliver 分支),
11772
+ * 确认后再由主 Agent 显式 dsh_workplan_dispatch。autoResume 链路不构成
11773
+ * 渗透点:armAutoResume 只在 finishRound(一轮派发结束后)触发,从未派发
11774
+ * 的 SALVAGED 记录进不了那条路径。
11775
+ */
11776
+ const plannerSalvaged = plannerTelemetry.outcome === 'SALVAGED'
11777
+ const autoDispatched = !planMode && !approvalHeld && options?.autoDispatch !== false && !plannerSalvaged
11178
11778
  /*
11179
11779
  * Plan-first: commit the plan with this step and let the main Agent call
11180
11780
  * dsh_workplan_dispatch. Dispatching here would hide the plan until every
@@ -11203,7 +11803,7 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
11203
11803
  if (!planMode) {
11204
11804
  if (approvalHeld) {
11205
11805
  /*
11206
- * [3.0.1] 认可闸门:durable 落档(与 mainDeepThink 同一写入口径,
11806
+ * [3.0.1] 认可闸门:durable 落档(与 mainStartPhases 同一写入口径,
11207
11807
  * subtaskId=null 计划级)——刷新/重启后回放读档,闸门不丢;
11208
11808
  * 随后发用户可见通知,计划保持 phase=pending、不派发。
11209
11809
  */
@@ -11230,12 +11830,53 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
11230
11830
  ])
11231
11831
  return
11232
11832
  }
11233
- deliver([planMessage])
11833
+ /*
11834
+ * [3.0.7] 用户已在分解期间确认:把确认事实与计划一起展示,让用户清楚
11835
+ * 本轮派发来自他自己的确认(而非系统自作主张)。后台分解本身就是「结合
11836
+ * 所有上下文的深入分析研究」,派发=依据分析结果分配任务;派发前刷新
11837
+ * conversationContext,让各部门 Agent 拿到含确认消息的全量上下文。
11838
+ */
11839
+ if (planningEntry.userConfirmed === true) {
11840
+ deliver([
11841
+ planMessage,
11842
+ makeUserMessage(
11843
+ '✅ 已采纳您此前的确认回复:后台分解(结合全部上下文的深入分析)已纳入您的确认,本计划不再等待认可,正在自动放行并派发。',
11844
+ { kind: 'workplan-confirm-dispatch', form: 'notice', summary: '已按用户确认自动放行并派发' },
11845
+ ),
11846
+ ])
11847
+ } else {
11848
+ deliver([planMessage])
11849
+ }
11234
11850
  if (autoDispatched) {
11851
+ if (planningEntry.userConfirmed === true) {
11852
+ record.conversationContext = recentConversation(session)
11853
+ }
11235
11854
  record.dispatchedAt = Date.now()
11236
11855
  // [T7] C3 整轮预算:自动派发同样重置(与显式派发同口径)。
11237
11856
  resetRoundInjectionBudget(session, `${record.plan.planId}:${record.dispatchedAt}`)
11238
11857
  state.startAutoDispatch?.(record, session, payload.agent)
11858
+ } else if (plannerSalvaged) {
11859
+ /*
11860
+ * [3.0.6][复审修复] 残缺计划的暂停通知:计划照展示(用户需要看到抢救
11861
+ * 结果),但什么都不开跑。计划级留痕进 record.errors,随 durable 回放
11862
+ * 不丢;用户确认后由主 Agent 显式 dispatch。
11863
+ */
11864
+ record.errors = [...(record.errors ?? []),
11865
+ '规划器只抢救出残缺计划(outcome=SALVAGED),已暂停自动执行;请人工确认后再 workplan_dispatch。'].slice(-20)
11866
+ deliver([
11867
+ makeUserMessage(
11868
+ [
11869
+ '⚠️ 规划器只抢救出残缺计划:模型输出在超时/中断前被截断,仅通过部分校验。',
11870
+ '为避免残缺计划在无人复核的情况下直接执行,本次已暂停自动派发。',
11871
+ '请人工核对该计划:确认可用后告知主 Agent 调用 dsh_workplan_dispatch 开跑;不可用可要求重新分解。',
11872
+ ].join('\n'),
11873
+ {
11874
+ kind: 'workplan-salvaged',
11875
+ form: 'notice',
11876
+ summary: '规划器只抢救出残缺计划,已暂停自动执行,请确认后再 workplan_dispatch',
11877
+ },
11878
+ ),
11879
+ ])
11239
11880
  }
11240
11881
  return
11241
11882
  }