dsh-workplan 3.0.2 → 3.0.6

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
@@ -355,6 +355,67 @@ export function describeSubagentActivationError(error: any, context: string): Er
355
355
  return error instanceof Error ? error : new Error(raw || String(error))
356
356
  }
357
357
 
358
+ /**
359
+ * [3.0.6][第 2 批] 宿主并发上限的“排队”而不是“判失败”。
360
+ *
361
+ * 宿主 `maxActiveSubagents`(默认 8)按**整棵会话树**共享;插件三层体系
362
+ * (5 个负责人 + 每人再派专家)很容易在某一刻撞上限。旧实现把
363
+ * `ACTIVATION_LIMIT_REACHED` 当普通失败:重试一次仍满就整行 `blocked`,
364
+ * 用户什么都没做错却看到“任务失败”。
365
+ *
366
+ * 现在在 `startActivation` 外层做**有界等待**:撞上限就退避后再试,直到
367
+ * 有空位、被取消、或等满 {@link ACTIVATION_QUEUE_MAX_WAIT_MS}。等待期间
368
+ * 不写失败状态、不消耗子任务 attempt;只有等满才如实报“仍未等到空位”。
369
+ *
370
+ * 多个等待者共享一个模块级冷却时间,避免同一毫秒一起撞门(惊群)。
371
+ * 这不是“精确信号量”(宿主没有暴露当前活跃数),而是“有界排队退避”:
372
+ * 空位一出现,等待者按退避节奏自然补位。
373
+ */
374
+ export const ACTIVATION_QUEUE_MAX_WAIT_MS = 10 * 60 * 1000
375
+ const ACTIVATION_QUEUE_BASE_DELAY_MS = 1000
376
+ const ACTIVATION_QUEUE_MAX_DELAY_MS = 15000
377
+ let activationQueueCooldownUntil = 0
378
+
379
+ export function isActivationLimitError(error: any): boolean {
380
+ if (String(error?.code ?? '') === 'ACTIVATION_LIMIT_REACHED') return true
381
+ return /limit reached/i.test(String(error?.message ?? error ?? ''))
382
+ }
383
+
384
+ export async function startActivationQueued<T>(
385
+ start: () => Promise<T>,
386
+ signal: any,
387
+ context: string,
388
+ ): Promise<T> {
389
+ const beganAt = Date.now()
390
+ let waits = 0
391
+ for (;;) {
392
+ try {
393
+ return await start()
394
+ } catch (error) {
395
+ if (!isActivationLimitError(error)) throw error
396
+ if (signal?.aborted) throw new PlanError('排队等待子代理空位时被取消', 'ABORTED')
397
+ const elapsed = Date.now() - beganAt
398
+ if (elapsed >= ACTIVATION_QUEUE_MAX_WAIT_MS) {
399
+ throw describeSubagentActivationError(
400
+ error,
401
+ `${context}:已排队等待 ${Math.round(elapsed / 1000)} 秒仍未等到空位`,
402
+ )
403
+ }
404
+ waits += 1
405
+ const backoff = Math.min(
406
+ ACTIVATION_QUEUE_MAX_DELAY_MS,
407
+ ACTIVATION_QUEUE_BASE_DELAY_MS * 2 ** Math.min(4, waits - 1),
408
+ )
409
+ const now = Date.now()
410
+ // 全局冷却只增不减:所有等待者共用同一个“下一次可以再试”的时刻。
411
+ activationQueueCooldownUntil = Math.max(activationQueueCooldownUntil, now + backoff)
412
+ const delay = Math.max(250, activationQueueCooldownUntil - now)
413
+ await sleepAbortable(signal, delay + Math.floor(Math.random() * 250))
414
+ if (signal?.aborted) throw new PlanError('排队等待子代理空位时被取消', 'ABORTED')
415
+ }
416
+ }
417
+ }
418
+
358
419
  export function deriveReportPending(record: any): boolean {
359
420
  const statuses = Array.isArray(record?.statuses) ? record.statuses : []
360
421
  /*
@@ -561,6 +622,13 @@ export const DISPOSE_TIMEOUT_MS = 5000
561
622
  export const STALE_PENDING_MS = 10 * 60 * 1000
562
623
  export const MAX_HISTORY_EVENTS = 2000
563
624
  export const MAX_LIVE_SESSIONS = 20
625
+ /**
626
+ * 看板响应上限按**字节**计,而不是 JavaScript 字符串长度。
627
+ * UTF-8 下一个汉字通常 3 字节:旧实现用 `body.length > 2_500_000`,中文响应
628
+ * 实际可发出约 7.5MB,远超注释承诺的 2.5MB。截断后也必须复检,否则 12 个
629
+ * 会话仍可能超限。
630
+ */
631
+ export const MAX_PLANS_RESPONSE_BYTES = 2_500_000
564
632
 
565
633
  function abortError() {
566
634
  return new PlanError('执行已取消', 'ABORTED')
@@ -2414,7 +2482,8 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2414
2482
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(不阻断派发)。
2415
2483
  notifyDepthOverrideConflict(ctx, typeof record?.plan?.sessionId === 'string' ? record.plan.sessionId : null)
2416
2484
  try {
2417
- activation = await ctx.subagents.startActivation({
2485
+ activation = await startActivationQueued(
2486
+ () => ctx.subagents.startActivation({
2418
2487
  provider: 'spawn',
2419
2488
  label: `${subtask.department}:${subtask.id} ${subtask.title}`.slice(0, 120),
2420
2489
  prompt: [{
@@ -2521,7 +2590,10 @@ async function executeSubtask(ctx: any, record: any, stage: any, subtask: any, o
2521
2590
  maxDepth: 2,
2522
2591
  signal: child.controller.signal,
2523
2592
  delivery: 'caller',
2524
- })
2593
+ }),
2594
+ child.controller.signal,
2595
+ `派发子任务 ${subtask.id}(${subtask.title})`,
2596
+ )
2525
2597
  } catch (error) {
2526
2598
  // [3.0.1][P1b] 并发上限翻译为可行动提示;其余错误原样上抛(保持旧行为)。
2527
2599
  throw describeSubagentActivationError(error, `派发子任务 ${subtask.id}(${subtask.title})`)
@@ -4829,6 +4901,40 @@ export function reconstructFromSession(session: any, targetPlanId?: string) {
4829
4901
  }
4830
4902
  const plan = chosen.plan
4831
4903
  const statuses = chosen.statuses
4904
+ /*
4905
+ * [3.0.6][复审修复] 僵尸 in_progress 回收:派发中途进程死亡 → 重启 → 回放
4906
+ * 重建出的行永远停在「正在做」,但没有任何存活 dispatchPromise 在调度它们
4907
+ * (canResumePlan 又只对 executing 放行,结果只能人工逐行改判)。重建路径
4908
+ * 天然不存在运行期派发,因此把残留的 in_progress 降级为 blocked:
4909
+ * 既有 resetBlockedStatuses/dispatch 路径即可正常接管续跑。行级 error 沿用
4910
+ * 本文件 settleStaleInflight(1.8.4)的同款收束写法:保留原说明、缺说明补
4911
+ * 一句人话;另往快照 errors 追加一条计划级留痕。运行期 in_progress 不在此
4912
+ * 误伤——那条路由 serialisePlan 的存活信号(dispatchPromise/turnEnded)收敛。
4913
+ *
4914
+ * 只收「还可能被派发」的计划:cancelled/superseded 的行状态是历史留痕
4915
+ * (workplan-255-cancel-replay R2 钉住取消后行状态原样回放),不做改写。
4916
+ * resultSeen 不豁免——暂停在中途的计划(结果消息已写、行停在 in_progress)
4917
+ * 恰恰是事故本体;而真正收尾的计划行全 done,本循环自然空转。
4918
+ */
4919
+ const ZOMBIE_INFLIGHT_ERROR = '重启后失联:派发中断,需重新派发'
4920
+ const zombieRecoveryApplies = !chosen.cancelled && !chosen.superseded
4921
+ let zombieRecovered = 0
4922
+ if (zombieRecoveryApplies) {
4923
+ for (const row of statuses) {
4924
+ if (row?.status !== 'in_progress') continue
4925
+ row.status = 'blocked'
4926
+ if (typeof row.error !== 'string' || row.error.trim() === '') row.error = ZOMBIE_INFLIGHT_ERROR
4927
+ zombieRecovered += 1
4928
+ }
4929
+ }
4930
+ if (zombieRecovered > 0) {
4931
+ console.warn(
4932
+ `[dsh-workplan] 回放回收 ${zombieRecovered} 条僵尸 in_progress 行`
4933
+ + `(计划 ${String(plan.planId)},派发中断后进程重启):已降级为 blocked,重新派发即可续跑。`,
4934
+ )
4935
+ chosen.errors = [...(chosen.errors ?? []),
4936
+ `${ZOMBIE_INFLIGHT_ERROR}(${zombieRecovered} 项已降级为 blocked,可重新派发续跑)`].slice(-20)
4937
+ }
4832
4938
  const resultPhase = chosen.resultPhase
4833
4939
  const resultSeen = chosen.resultSeen
4834
4940
  const resumeCount = chosen.resumeCount
@@ -5002,6 +5108,63 @@ function respondJson(res: any, status: any, payload: any) {
5002
5108
  res.end(body)
5003
5109
  }
5004
5110
 
5111
+ /**
5112
+ * 响应超限时逐级收缩:先减会话数,再丢单会话的大块明细,最后只留摘要。
5113
+ * 任何一级都返回**合法 JSON**;宁可少给字段,也不返回半截字符串。
5114
+ */
5115
+ export function trimPlansPayload(payload: any): any {
5116
+ const fits = (value: any) => Buffer.byteLength(JSON.stringify(value)) <= MAX_PLANS_RESPONSE_BYTES
5117
+ if (fits(payload)) return payload
5118
+ const original = Array.isArray(payload?.sessions) ? payload.sessions.slice() : []
5119
+ let sessions = original.slice()
5120
+ let trimmed: any = { ...payload, truncated: true, sessions }
5121
+ while (!fits(trimmed) && sessions.length > 1) {
5122
+ sessions = sessions.slice(0, Math.max(1, Math.ceil(sessions.length / 2)))
5123
+ trimmed = { ...trimmed, sessions }
5124
+ }
5125
+ if (!fits(trimmed)) {
5126
+ sessions = sessions.map((item: any) => ({
5127
+ sessionId: item.sessionId,
5128
+ planId: item.planId,
5129
+ title: typeof item.title === 'string' ? truncate(item.title, 200) : item.title,
5130
+ phase: item.phase,
5131
+ suspendedPhase: item.suspendedPhase,
5132
+ endedAt: item.endedAt,
5133
+ stats: item.stats,
5134
+ departments: item.departments,
5135
+ statuses: Array.isArray(item.statuses) ? item.statuses.slice(-50) : [],
5136
+ createdAt: item.createdAt,
5137
+ updatedAt: item.updatedAt,
5138
+ running: item.running,
5139
+ deliveryReady: item.deliveryReady,
5140
+ plan: item.plan ? { planId: item.plan.planId, title: item.plan.title } : null,
5141
+ omittedDetail: true,
5142
+ }))
5143
+ trimmed = { ...trimmed, sessions }
5144
+ }
5145
+ if (!fits(trimmed)) {
5146
+ trimmed = {
5147
+ ...trimmed,
5148
+ sessions: sessions.map((item: any) => ({
5149
+ sessionId: item.sessionId,
5150
+ planId: item.planId,
5151
+ title: typeof item.title === 'string' ? truncate(item.title, 120) : item.title,
5152
+ phase: item.phase,
5153
+ omittedDetail: true,
5154
+ })),
5155
+ }
5156
+ }
5157
+ // 极端情况(例如单条 title 本身就巨大):只保留会话计数,保证响应仍是合法 JSON。
5158
+ if (!fits(trimmed)) {
5159
+ trimmed = {
5160
+ ...trimmed,
5161
+ sessions: [],
5162
+ omittedSessions: original.length,
5163
+ }
5164
+ }
5165
+ return trimmed
5166
+ }
5167
+
5005
5168
  export type WorkplanRuntimeOptions = {
5006
5169
  cwd?: string
5007
5170
  /**
@@ -5073,6 +5236,18 @@ export type WorkplanRuntimeOptions = {
5073
5236
  * 以非零退出码结束(packages/bundle/headless/src/index.ts 的 fail())。
5074
5237
  */
5075
5238
  failClosedOnIncomplete?: boolean | 'auto'
5239
+ /**
5240
+ * [3.0.6][第 3 批①] `agent/turn-stopping` 里等待在途规划/派发的上限(毫秒)。
5241
+ *
5242
+ * 审计病根:收尾闸门会无界等待 `planning.promise`(最坏 3 次 × 900s = 45 分钟)
5243
+ * 和 `record.dispatchPromise`(执行无时限 ⇒ 理论上无限),用户取消都没有反应
5244
+ * 窗口。本上限只约束「收尾闸门的等待」,**不**给部门/专家执行加任何时限
5245
+ * (既定语义不变):到点后回合按「等待预算耗尽」如实收尾/失败,后台派发
5246
+ * 继续跑、结果消息照常落盘。
5247
+ *
5248
+ * 默认 60 分钟(3,600,000);`0` = 无限等待(回到旧行为)。
5249
+ */
5250
+ turnStoppingMaxWaitMs?: number
5076
5251
  /**
5077
5252
  * [1.8.13] Package version, supplied by the host from its `meta.version`.
5078
5253
  *
@@ -5215,6 +5390,13 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
5215
5390
  emitSubtaskDoneNotice(recordArg, session, subtask, verdict),
5216
5391
  }
5217
5392
  record.dispatchStartedAt = Date.now()
5393
+ /*
5394
+ * [3.0.6][第 3 批①] 复用同一 record 再派发时清零等待耗尽标记:否则 auto-resume/
5395
+ * continue/重派之后,onTurnStopping 会把下一回合按"已耗尽"零预算秒放行,
5396
+ * 且 waitExhaustedNotifiedTurn 只按 turn 去重,导致每回合误发 ⏳ 上限通知。
5397
+ */
5398
+ record.turnWaitExhausted = undefined
5399
+ record.waitExhaustedNotifiedTurn = undefined
5218
5400
  record.dispatchPromise = dispatchPlan(ctx, record, {
5219
5401
  ...roundOptions,
5220
5402
  signal: controller.signal,
@@ -6453,6 +6635,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
6453
6635
  // 新一轮必须写一条新的结果消息,否则主 Agent 永远看不到自动续跑的结局。
6454
6636
  record.resultWritten = false
6455
6637
  book.doneBefore = Number(live.stats?.done ?? 0)
6638
+ // [3.0.6][第 3 批①] 自动续跑同样复用原 record:派发前清零等待耗尽标记(同 startAutoDispatch)。
6639
+ record.turnWaitExhausted = undefined
6640
+ record.waitExhaustedNotifiedTurn = undefined
6456
6641
  record.dispatchPromise = dispatchPlan(ctx, record, {
6457
6642
  ...base,
6458
6643
  // [2.2.0][T6/O-1a] 自动续跑同样在后台执行:保持完成即时通知。
@@ -6992,6 +7177,27 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
6992
7177
  if (rebuilt?.plan) record = rebuilt
6993
7178
  }
6994
7179
  if (!record?.plan) {
7180
+ /*
7181
+ * [T3][M7 在途可见] 计划尚未落盘、但后台自动分解正在进行时,不得误报"没有计划"
7182
+ * (T1 失效分支 F4:在途不可见曾让用户与主 Agent 误判为"分配器无对象、任务未开始",
7183
+ * 正是本次缺陷的直接观感)。返回 PLANNING_IN_FLIGHT,附带已耗时与明确下一步,
7184
+ * 与真正的 NO_PLAN 区分。仅读取 state.planningInFlight,不写任何状态。
7185
+ */
7186
+ const inFlight = state.planningInFlight?.get(session.id)
7187
+ if (inFlight) {
7188
+ /* [R2 修正] ok 取 false,与 NO_PLAN 一致:在途意味着「还没有可用计划」,避免调用方
7189
+ * 把 ok:true 误读为「已有计划」。code=PLANNING_IN_FLIGHT 与 hint 明确区分原因与下一步。 */
7190
+ return {
7191
+ ok: false,
7192
+ code: 'PLANNING_IN_FLIGHT',
7193
+ running: false,
7194
+ version: pluginVersion,
7195
+ runtime: runtimeIdentity(),
7196
+ elapsedMs: Date.now() - Number(inFlight.startedAt ?? Date.now()),
7197
+ error: '',
7198
+ hint: '任务分解进行中,计划生成后会话将自动出现计划;请稍后再查看,或等待分配通知。',
7199
+ }
7200
+ }
6995
7201
  /*
6996
7202
  * [1.8.14] N1/§14.6 step 2: the identity of the loaded build must be
6997
7203
  * answerable even before a plan exists. 1.8.13 returned NO_PLAN with no
@@ -7168,21 +7374,21 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7168
7374
  const expectedAcceptance = Array.isArray(found?.subtask?.acceptance) ? found.subtask.acceptance : []
7169
7375
  const rawPhases = isRecord(args?.phases)
7170
7376
  ? args.phases
7171
- : { planning: args?.planning, execution: args?.execution, verification: args?.verification }
7377
+ : { planning: args?.planning, preparation: args?.preparation, execution: args?.execution, verification: args?.verification }
7172
7378
  const check = validatePhaseEvidence(rawPhases, expectedAcceptance)
7173
7379
  if (!check.ok || !check.phases) {
7174
7380
  const gate = phaseGateFromErrors(check.errors)
7175
7381
  return {
7176
7382
  ok: false,
7177
7383
  passed: false,
7178
- code: gate === 'phase-1-2' ? 'PHASE_GATE' : 'VERIFICATION_INCOMPLETE',
7384
+ code: gate === 'phase-1-3' ? 'PHASE_GATE' : 'VERIFICATION_INCOMPLETE',
7179
7385
  phase: gate,
7180
7386
  planId: record.plan.planId,
7181
7387
  subtaskId: row.subtaskId,
7182
7388
  gaps: check.errors,
7183
- error: gate === 'phase-1-2'
7184
- ? `阶段三核验缺少前两阶段证据:先完成「梳理问题 → 形成可执行思路」并实际执行,再提交阶段三核验。${check.errors.slice(0, 5).join(';')}`
7185
- : `阶段三核验未通过:${check.errors.slice(0, 5).join(';')}`,
7389
+ error: gate === 'phase-1-3'
7390
+ ? `核验缺少前几步证据:先完成「梳理任务 → 研究资源工具方案 → 准备到位 → 执行」并按步写全证据,再提交验证核验。${check.errors.slice(0, 5).join(';')}`
7391
+ : `验证核验未通过:${check.errors.slice(0, 5).join(';')}`,
7186
7392
  }
7187
7393
  }
7188
7394
  return {
@@ -7192,7 +7398,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7192
7398
  planId: record.plan.planId,
7193
7399
  subtaskId: row.subtaskId,
7194
7400
  summary: phaseSummaryLine(check.phases),
7195
- message: '插件核验通过:三阶段证据齐全、验证全部通过。现在把同一份 phases 写进结果块并提交。',
7401
+ message: '插件核验通过:前四步证据齐全、验证全部通过。现在把同一份 phases 写进结果块,并按第五步以 JSON mode 交回本部门负责人。',
7196
7402
  }
7197
7403
  }
7198
7404
 
@@ -7353,7 +7559,14 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7353
7559
  const journalInfo = journal.result.ok ? {} : { journal: { ok: false, code: journal.result.code, error: journal.result.error } }
7354
7560
  const revision = Number(row.revision ?? 0) + 1
7355
7561
  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 } }
7562
+ ? {
7563
+ ...item,
7564
+ // [3.0.5] 待指示必须显式落在第三层台账:负责人改派闸门与看板都读这个字段。
7565
+ closure: 'escalated',
7566
+ blockedKind: 'escalated',
7567
+ error: question,
7568
+ escalation: { question, options, needs, at: now, ...(messageId ? { messageId } : {}), delivery },
7569
+ }
7357
7570
  : item))
7358
7571
  record.statuses = applyStatus(record.statuses, row.subtaskId, { delegates, revision, updatedBy: 'child' })
7359
7572
  record.updatedAt = now
@@ -7869,6 +8082,21 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7869
8082
  if (memberName && targetSessionId && target.childId !== targetSessionId) {
7870
8083
  return { ok: false, code: 'NOT_DELEGATE', subtaskId, error: 'member 与 sessionId 指向不同成员,拒绝投递' }
7871
8084
  }
8085
+ /*
8086
+ * [3.0.5] 指示只能答复「已经提交请示」的原专家:这从机制上保证用户要求的
8087
+ * 四步闭环——专家先上报问题,负责人梳理全部任务状态并研究方案后,只能把
8088
+ * 解决方案下发给原专家继续执行;不能借 instruct 把未请示成员当作替代人选。
8089
+ */
8090
+ if (!target?.escalation && target?.closure !== 'escalated') {
8091
+ return {
8092
+ ok: false,
8093
+ code: 'NOT_ESCALATED',
8094
+ subtaskId,
8095
+ member: target?.member,
8096
+ error: `第三层成员 ${String(target?.member ?? '?')} 不在待指示状态:只有已提交请示的原专家才能接收指示。`,
8097
+ hint: '若该成员遇阻,先让其调用 dsh_workplan_escalate;待指示期间禁止 review/dispatch/direct 改派给其他专家。',
8098
+ }
8099
+ }
7872
8100
  const childId = typeof target.childId === 'string' ? target.childId : ''
7873
8101
  if (!childId) {
7874
8102
  return { ok: false, code: 'NOT_DELEGATE', subtaskId, member: target.member, error: '该成员没有登记子会话 childId,无法投递指示' }
@@ -7889,7 +8117,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
7889
8117
  // inReplyTo(可选):从留痕回放找该成员最近一条请示消息 id;读失败不阻断投递。
7890
8118
  let inReplyTo = ''
7891
8119
  try {
7892
- const prior = readDeptMessages(record.plan.planId, { kind: 'escalation' })
8120
+ const prior = readDeptMessages(record.plan.planId, { kind: 'escalation', newest: true })
7893
8121
  if (prior.ok) {
7894
8122
  const match = [...prior.messages].reverse().find((m: any) => m.from?.sessionId === childId && m.subtaskId === subtaskId)
7895
8123
  inReplyTo = match?.id ?? ''
@@ -8520,7 +8748,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8520
8748
  for (let i = 0; i < 2; i += 1) {
8521
8749
  try {
8522
8750
  // [2.5.5][治本] 第三处 spawn 同口径:spec 顶层契约(prompt/parent/cwd/agentOptions/maxDepth)。
8523
- activation = await ctx.subagents.startActivation({
8751
+ activation = await startActivationQueued(
8752
+ () => ctx.subagents.startActivation({
8524
8753
  provider: 'spawn',
8525
8754
  label: `${row.department}:${subtaskId}→${member.member}(self:${selfEffort})`.slice(0, 120),
8526
8755
  prompt: [{ type: 'text', text: promptText }],
@@ -8539,7 +8768,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8539
8768
  */
8540
8769
  signal: new AbortController().signal,
8541
8770
  delivery: 'caller',
8542
- })
8771
+ }),
8772
+ undefined,
8773
+ `自配档接续(成员 ${member.member})`,
8774
+ )
8543
8775
  break
8544
8776
  } catch (error) { lastError = error }
8545
8777
  }
@@ -8699,6 +8931,31 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8699
8931
  return persist({ gateAudit: [...prior, entry].slice(-20) })
8700
8932
  }
8701
8933
 
8934
+ /*
8935
+ * [3.0.5] 用户改进方案 1/2 的硬机制:第三层任何专家进入「待指示」后,部门负责
8936
+ * 人不得借 review/dispatch/direct 把相关问题改派、重派或降级给其他人;必须先
8937
+ * 全面梳理该问题与本部门全部 delegates 执行状态,研究方案后用 dsh_workplan_
8938
+ * instruct 答复原成员,由原成员继续执行。这里硬拒的是「换人/重派」动作,
8939
+ * status 仍放行,保证负责人能看到当前所有任务状态并履行研究义务。
8940
+ */
8941
+ const openEscalations = (Array.isArray(row.delegates) ? row.delegates : [])
8942
+ .filter((item: any) => Boolean(item?.escalation) || item?.closure === 'escalated')
8943
+ if (openEscalations.length > 0 && ['review', 'dispatch', 'direct'].includes(action)) {
8944
+ const members = openEscalations.map((item: any) => String(item?.member ?? '?'))
8945
+ recordGate(action as 'review' | 'dispatch' | 'direct', false, 'DELEGATE_ESCALATION_OPEN')
8946
+ return {
8947
+ ok: false,
8948
+ code: 'DELEGATE_ESCALATION_OPEN',
8949
+ subtaskId,
8950
+ members,
8951
+ delegates: row.delegates,
8952
+ error: `第三层已有成员待指示(${members.join('、')}):禁止改派、重派或降级给其他人。`
8953
+ + '必须先全面梳理该成员遇到的问题与本部门全部已派发任务的执行状态,研究形成解决方案后,'
8954
+ + '用 dsh_workplan_instruct 答复原成员;平台会强制由原成员继续执行。',
8955
+ hint: '先用 action="status" 查看全部 delegates;对每位待指示成员执行 dsh_workplan_instruct(subtaskId=本部门行 ID,member=待指示成员)。待指示清零后才允许 review/dispatch/direct。',
8956
+ }
8957
+ }
8958
+
8702
8959
  if (action === 'status') {
8703
8960
  const delegates = Array.isArray(row.delegates) ? row.delegates : []
8704
8961
  return {
@@ -8711,6 +8968,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8711
8968
  // [2.5.4][T3R1] 门禁审计对负责人可见(A3:拒绝/放行记录可复核)。
8712
8969
  gateAudit: Array.isArray(row.gateAudit) ? row.gateAudit : [],
8713
8970
  delegates,
8971
+ // [3.0.5] 待指示成员清单:负责人履行「先梳理全部任务状态」义务的读取面。
8972
+ openEscalations: openEscalations.map((item: any) => String(item?.member ?? '?')),
8714
8973
  // [T7][lead-decisions J2] 负责人时长聚合:与看板/模型面同一读时派生纯函数
8715
8974
  // (J1 冻结结构;null=无下属分工/replanned 旧行/越界 fail-closed,J8/R8)。
8716
8975
  leaderEstimate: deriveLeaderEstimate(row),
@@ -8723,7 +8982,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
8723
8982
  ? '尚未提交梳理产物:先调用 action="review"(用户要求 4 的硬门禁)。'
8724
8983
  : delegates.length === 0
8725
8984
  ? '梳理产物已登记,可调用 action="dispatch" 正式派发给本部门全球顶尖专家。'
8726
- : '第三层已派发;各下级结论会送回本会话,收齐后汇总核验,再写最终结果块。若有成员 closure=escalated(待指示),必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,不要沉默略过。',
8985
+ : openEscalations.length > 0
8986
+ ? `第三层已有 ${openEscalations.length} 名成员待指示(${openEscalations.map((item: any) => String(item?.member ?? '?')).join('、')}):按 3.0.5 硬规则禁止 review/dispatch/direct 改派;必须先全面梳理该问题与本部门全部任务状态,研究方案后用 dsh_workplan_instruct 答复原成员,由原成员继续执行。`
8987
+ : '第三层已派发;各下级结论会送回本会话,收齐后汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」:必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。',
8727
8988
  }
8728
8989
  }
8729
8990
 
@@ -9004,7 +9265,8 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9004
9265
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(scope=计划根会话)。
9005
9266
  notifyDepthOverrideConflict(ctx, typeof parentSession?.header?.parentSession === 'string' ? parentSession.header.parentSession : (typeof parentId === 'string' ? parentId : null))
9006
9267
  // [2.5.5][治本] 同 executeSubtask:spec 顶层契约(prompt/parent/cwd/agentOptions/maxDepth)。
9007
- const activation = await ctx.subagents.startActivation({
9268
+ const activation = await startActivationQueued<any>(
9269
+ () => ctx.subagents.startActivation({
9008
9270
  provider: 'spawn',
9009
9271
  label: `${row.department}:${subtaskId}→${assignment.member}`.slice(0, 120),
9010
9272
  prompt: [{ type: 'text', text: promptText }],
@@ -9021,7 +9283,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9021
9283
  maxDepth: 2,
9022
9284
  signal,
9023
9285
  delivery: 'caller',
9024
- })
9286
+ }),
9287
+ signal,
9288
+ `派发成员 ${assignment.member}(${subtaskId})`,
9289
+ )
9025
9290
  childId = typeof activation?.childId === 'string' ? activation.childId : null
9026
9291
  if (activation && typeof activation.result?.then === 'function') {
9027
9292
  const settledChildId = childId
@@ -9108,7 +9373,7 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9108
9373
  taskEffort: delegationPlan.taskEffort,
9109
9374
  effortOverride: written?.effortOverride ?? row.effortOverride ?? null,
9110
9375
  ...(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)答复,投递成功后该成员恢复执行。',
9376
+ hint: '第三层已派发(一层下级、叶子层,第四层会被硬拒)。每位全球顶尖专家的完成结论会送回本会话(delivery=caller);收齐后由你汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」(delegates[].closure=escalated):必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。3.0.5 硬规则:任何成员待指示期间,review/dispatch/direct 一律拒绝改派,必须由原成员继续执行。',
9112
9377
  }
9113
9378
  }
9114
9379
 
@@ -9389,6 +9654,9 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9389
9654
  onSubtaskDone: (recordArg: any, subtask: any, verdict: any) =>
9390
9655
  emitSubtaskDoneNotice(recordArg, session, subtask, verdict),
9391
9656
  }
9657
+ // [3.0.6][第 3 批①] 人工派发/续派复用原 record:派发前清零等待耗尽标记(同 startAutoDispatch)。
9658
+ record.turnWaitExhausted = undefined
9659
+ record.waitExhaustedNotifiedTurn = undefined
9392
9660
  record.dispatchPromise = dispatchPlan(ctx, record, {
9393
9661
  ...roundOptions,
9394
9662
  signal: dispatchController.signal,
@@ -9487,6 +9755,40 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9487
9755
  */
9488
9756
  const STOP_STEER_LIMIT = 2
9489
9757
 
9758
+ /*
9759
+ * [3.0.6][第 3 批①] 收尾等待上限(解析一次,全路径同值)。
9760
+ * ≤0 = 无限等待(旧行为);默认 60 分钟。只约束 turn-stopping 的等待,
9761
+ * 不构成部门/专家的执行时限。
9762
+ */
9763
+ const turnStoppingMaxWaitMs = (() => {
9764
+ const raw = Number(options.turnStoppingMaxWaitMs)
9765
+ return Number.isFinite(raw) && raw > 0 ? raw : 0
9766
+ })()
9767
+
9768
+ /**
9769
+ * 带上限地等待一个收尾承诺。capMs<=0 时等同无限等待(旧行为)。
9770
+ * 返回 true = 按时结算;false = 等满上限(调用方决定如何收尾)。
9771
+ * 承诺自身结算后绝不再被本函数消费——由调用方一次性判定。
9772
+ */
9773
+ async function waitTurnPromise(promise: Promise<any>, capMs: number): Promise<boolean> {
9774
+ if (!(capMs > 0)) {
9775
+ try { await promise } catch { /* 结算失败已由产出方留痕 */ }
9776
+ return true
9777
+ }
9778
+ let timer: any = null
9779
+ try {
9780
+ const timeout = new Promise<'timeout'>((resolve) => {
9781
+ // 收束类计时器:到点即状态转移(等待预算耗尽),禁止 unref
9782
+ // (handle-policy 契约;到点必然被 clearTimeout 或先行触发)。
9783
+ timer = setTimeout(() => resolve('timeout'), capMs)
9784
+ })
9785
+ const outcome = await Promise.race([promise.then(() => 'settled' as const, () => 'settled' as const), timeout])
9786
+ return outcome === 'settled'
9787
+ } finally {
9788
+ if (timer) clearTimeout(timer)
9789
+ }
9790
+ }
9791
+
9490
9792
  function recordReadiness(record: any) {
9491
9793
  return readinessOf(record)
9492
9794
  }
@@ -9797,6 +10099,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9797
10099
  * pre-step;若只在那里 supersede,旧规划仍会跑完并迟到交付。官方
9798
10100
  * `agent/inbox/inserted` 在消息进入 live inbox 时即发本事件,因此这里先中止。
9799
10101
  * 内部 workplan 通知、社交/状态/空泛续跑均不取消;同任务重复投递保持幂等。
10102
+ * [T3][M2 取代显式通知] 与 pre-step 取代路径同一缺口:此处只置 superseded +
10103
+ * abort,全程静默,用户看到的就是"任务没分配"且无任何解释。这里补同一条
10104
+ * 用户可见取代通知;alreadySuperseded 守卫保证连续多条新消息只通知一次(幂等),
10105
+ * 且绝不恢复旧计划、绝不写 state.records,避免迟到覆盖新任务占位记录。
9800
10106
  */
9801
10107
  function onInboxInserted(payload: any) {
9802
10108
  const session = payload?.agent?.session
@@ -9808,8 +10114,14 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9808
10114
  const taskText = taskTextFromMessages([message])
9809
10115
  if (!taskText || isSocialMessage(taskText) || isVagueContinuation(taskText) || isStatusQuestion(taskText)) return
9810
10116
  if (planning.taskText === taskText) return
10117
+ const alreadySuperseded = planning.superseded === true
9811
10118
  planning.superseded = true
9812
10119
  planning.controller.abort()
10120
+ if (!alreadySuperseded) {
10121
+ appendUserMessage(session,
10122
+ '【dsh-workplan·任务分解被取代】你上一条任务的后台自动分解已被本条新消息中止,原任务不会自动分配。\n' +
10123
+ '如仍需执行原任务:请重新发送该任务,或说"重新生成计划并执行";也可以让我先手动制定计划给你确认后再执行。')
10124
+ }
9813
10125
  }
9814
10126
 
9815
10127
  async function onTurnStopping(payload: any) {
@@ -9833,8 +10145,21 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9833
10145
  */
9834
10146
  let record = state.records.get(session.id) ?? known
9835
10147
  const planning = state.planningInFlight?.get(session.id)
9836
- if (planning?.promise) {
9837
- try { await planning.promise } catch { /* 后台规划自身已记录降级/错误 */ }
10148
+ if (planning?.promise && planning.turnWaitTimedOut !== true) {
10149
+ /*
10150
+ * [3.0.6][第 3 批①] 收尾等待上限:规划在途时最多等
10151
+ * turnStoppingMaxWaitMs(默认 60 分钟;0=无限)。到点不再等,标记
10152
+ * turnWaitTimedOut(同一规划对象只等一次,后续收尾不再重复等待),
10153
+ * 按规划未完成继续走下方既有闸门(有界 steer / fail-closed)。
10154
+ */
10155
+ const settled = await waitTurnPromise(planning.promise, turnStoppingMaxWaitMs)
10156
+ if (!settled) {
10157
+ planning.turnWaitTimedOut = true
10158
+ ctx.logger?.warn?.(
10159
+ `dsh-workplan: 回合 ${turn} 等待在途规划达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟,`
10160
+ + '按「等待预算耗尽」继续收尾检查(规划仍在后台,完成后的交回逻辑不受影响)',
10161
+ )
10162
+ }
9838
10163
  /*
9839
10164
  * 等待期间若同回合后续 step 已用新任务取代旧规划,本次旧收尾必须退出;
9840
10165
  * 新规划的收尾会自行等待并交回,绝不能在这里消费旧结果或误 steer。
@@ -9866,12 +10191,77 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9866
10191
  if (isPlanModeActive(ctx, session)) return
9867
10192
  if (!stopGateApplies(record, session, turn)) return
9868
10193
  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 */
10194
+ if (record.turnWaitExhausted) {
10195
+ /*
10196
+ * [3.0.6][第 3 批①] 本轮(及后续回合)已耗尽过等待预算且派发仍在跑:
10197
+ * 不再重复等待,直接走下方「放行但留痕」分支,回合如实收尾。
10198
+ */
10199
+ } else {
10200
+ const settled = await waitTurnPromise(record.dispatchPromise, turnStoppingMaxWaitMs)
10201
+ if (!settled) {
10202
+ record.turnWaitExhausted = { turn, at: Date.now(), waitedMs: turnStoppingMaxWaitMs }
10203
+ record.errors = [...(record.errors ?? []), `回合收尾等待派发达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟(等待预算耗尽,派发仍在后台执行)`].slice(-20)
10204
+ ctx.logger?.warn?.(
10205
+ `dsh-workplan: 回合 ${turn} 等待派发达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟:`
10206
+ + `计划 ${record.plan?.planId} 仍在后台执行,结果消息会照常落盘`,
10207
+ )
10208
+ if (failClosedActive) {
10209
+ throw new PlanError(
10210
+ `等待预算耗尽:回合收尾已连续等待派发超过 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟`
10211
+ + `(计划 ${record.plan?.planId} 仍在后台执行,本回合不再等待)。headless 以非零退出码结束,不输出「已完成」结果。`,
10212
+ 'WORKPLAN_WAIT_EXHAUSTED',
10213
+ { planId: record.plan?.planId },
10214
+ )
10215
+ }
10216
+ }
10217
+ }
10218
+ if (!record.turnWaitExhausted) {
10219
+ try {
10220
+ await record.dispatchPromise
10221
+ } catch {
10222
+ /* the failure is already on record.errors; the gate only needs the outcome */
10223
+ }
10224
+ finishRound(record, session)
10225
+ }
10226
+ if (record.turnWaitExhausted) {
10227
+ /*
10228
+ * 等待预算耗尽的放行与 steer 用尽同一套「放行但留痕」语义:
10229
+ * 不 steer(避免再拖住回合)、记 releasedIncomplete、追加 notice。
10230
+ * fail-closed 已在上方抛错,不会走到这里。
10231
+ */
10232
+ const stuck = derivePlanSnapshot(record.statuses)
10233
+ const released = (stuck.statuses ?? [])
10234
+ .filter((item: any) => item.status !== 'done')
10235
+ .map((item: any) => String(item.subtaskId))
10236
+ record.releasedIncomplete = {
10237
+ turn,
10238
+ at: Date.now(),
10239
+ done: stuck.stats.done,
10240
+ total: stuck.stats.total,
10241
+ remaining: released,
10242
+ reason: 'wait-exhausted',
10243
+ }
10244
+ try {
10245
+ if (record.waitExhaustedNotifiedTurn !== turn) {
10246
+ record.waitExhaustedNotifiedTurn = turn
10247
+ appendUserMessage(session, makeUserMessage(
10248
+ [
10249
+ `⏳ 本轮等待派发已达上限(${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟),按计划仍在后台执行,本回合先行收尾(计划 ${record.plan.planId})`,
10250
+ `进度 ${stuck.stats.done}/${stuck.stats.total};未完成:${released.join(', ') || '无'}`,
10251
+ '后台结果照常落盘:稍后可用 dsh_workplan_status 查看,或在下一回合继续。',
10252
+ ].join('\n'),
10253
+ {
10254
+ kind: 'workplan-release',
10255
+ form: 'notice',
10256
+ summary: `等待预算耗尽放行 ${stuck.stats.done}/${stuck.stats.total}`,
10257
+ },
10258
+ ))
10259
+ }
10260
+ } catch (error) {
10261
+ ctx.logger?.warn?.(`dsh-workplan: 等待耗尽放行留痕写入失败:${error instanceof Error ? error.message : String(error)}`)
10262
+ }
10263
+ return
9873
10264
  }
9874
- finishRound(record, session)
9875
10265
  if (!stopGateApplies(record, session, turn)) return
9876
10266
  }
9877
10267
  const book = record.stopSteers && record.stopSteers.turn === turn
@@ -9980,8 +10370,10 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
9980
10370
  /*
9981
10371
  * [1.12.3] fail-closed 的硬失败必须穿过这层日志包装:
9982
10372
  * 这里原本把任何异常降级成一条 warn,等于把上面的抛错又吃掉。
10373
+ * [3.0.6] WORKPLAN_WAIT_EXHAUSTED 同属硬失败(等待预算耗尽),同样必须穿透。
9983
10374
  */
9984
- if (error instanceof PlanError && error.code === 'WORKPLAN_INCOMPLETE') throw error
10375
+ if (error instanceof PlanError
10376
+ && (error.code === 'WORKPLAN_INCOMPLETE' || error.code === 'WORKPLAN_WAIT_EXHAUSTED')) throw error
9985
10377
  ctx.logger?.warn?.(`dsh-workplan: 回合收尾检查失败:${error instanceof Error ? error.message : String(error)}`)
9986
10378
  }
9987
10379
  }
@@ -10482,8 +10874,17 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
10482
10874
  async function route(req: any, res: any, connectionCtx: any = ctx) {
10483
10875
  applyHardeningHeaders(res)
10484
10876
  let rejection
10877
+ /*
10878
+ * 鉴权 fail-closed:connection 服务存在但没有 requestRejection(宿主 API 改名/降级)时,
10879
+ * 旧实现会因可选链返回 undefined 而直接放行,等于把全部会话计划暴露给未鉴权请求。
10880
+ * 看板是敏感数据路由,宁可直接拒绝,也不能在“检查器不见了”时默认通过。
10881
+ */
10882
+ if (typeof connectionCtx?.connection?.requestRejection !== 'function') {
10883
+ respondJson(res, 503, { ok: false, error: '鉴权服务不可用,已拒绝访问' })
10884
+ return
10885
+ }
10485
10886
  try {
10486
- rejection = await Promise.resolve(connectionCtx?.connection?.requestRejection?.(req))
10887
+ rejection = await Promise.resolve(connectionCtx.connection.requestRejection(req))
10487
10888
  } catch {
10488
10889
  respondJson(res, 403, { ok: false, error: '未授权的请求' })
10489
10890
  return
@@ -10512,11 +10913,11 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
10512
10913
  return
10513
10914
  }
10514
10915
  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
10916
+ let payload: any = plansPayload(url.searchParams.get('sessionId') ?? undefined)
10917
+ let body = JSON.stringify(payload)
10918
+ if (Buffer.byteLength(body) > MAX_PLANS_RESPONSE_BYTES) {
10919
+ payload = trimPlansPayload(payload)
10920
+ body = JSON.stringify(payload)
10520
10921
  }
10521
10922
  if (req.method === 'HEAD') {
10522
10923
  res.writeHead(200, {
@@ -10547,7 +10948,17 @@ export function createWorkplanRuntime(ctx: any, options: WorkplanRuntimeOptions
10547
10948
  * 用户要求这些经验必须能被复核。主 Agent 在阶段三可以用它查:记住了什么、
10548
10949
  * 哪些同类错误在重复发生、文件到底写在哪。它只读文件,不改任何计划状态。
10549
10950
  */
10550
- async function lessonsTool(_agent: any, args: any) {
10951
+ /*
10952
+ * [3.0.6][复审修复] 数据面越权:lessons.jsonl 是跨项目的全局永久记忆(含
10953
+ * 其它项目 cwd 与问题描述),此前无任何会话校验,任意子 Agent(含其它插件
10954
+ * 拉起的子会话)都能读走。这里与其它工具(update/replan/cancel 等)同一
10955
+ * 写法加 isRootSession 硬校验:非根会话直接抛权限错误,不依赖提示词约束;
10956
+ * 根会话行为不变。
10957
+ */
10958
+ async function lessonsTool(agent: any, args: any) {
10959
+ const session = agent?.session
10960
+ if (!session) throw new PlanError('只能在会话内查询永久教训记忆', 'NO_SESSION')
10961
+ if (!isRootSession(session)) throw new PlanError('子 Agent 不能读取全局永久教训记忆', 'NOT_ROOT')
10551
10962
  const parsed = isRecord(args) ? args : {}
10552
10963
  const action = String(parsed.action ?? 'list')
10553
10964
  const file = resolveLessonsFile()
@@ -10719,8 +11130,21 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
10719
11130
  const priorPlanning = state.planningInFlight?.get(session.id)
10720
11131
  if (priorPlanning) {
10721
11132
  if (priorPlanning.taskText === taskText) return downstream
11133
+ /*
11134
+ * [T3][M2 取代显式通知] 原任务的后台自动分解被本条新消息取代。T1 根因:此处置旧规划
11135
+ * 只置 superseded + abort,全程静默,用户看到的就是"任务没分配"且无任何解释。这里补一条
11136
+ * 用户可见降级通知。边界沿用 11099 注释的防御意图:绝不恢复旧计划、绝不写 state.records
11137
+ * (避免迟到覆盖新任务占位记录);通知只走 appendUserMessage(与规划预告/心跳同一合规
11138
+ * 写入器)。alreadySuperseded 守卫保证连续多条新消息只在首次取代时通知一次(幂等)。
11139
+ */
11140
+ const alreadySuperseded = priorPlanning.superseded === true
10722
11141
  priorPlanning.superseded = true
10723
11142
  priorPlanning.controller.abort()
11143
+ if (!alreadySuperseded) {
11144
+ appendUserMessage(session,
11145
+ '【dsh-workplan·任务分解被取代】你上一条任务的后台自动分解已被本条新消息中止,原任务不会自动分配。\n' +
11146
+ '如仍需执行原任务:请重新发送该任务,或说"重新生成计划并执行";也可以让我先手动制定计划给你确认后再执行。')
11147
+ }
10724
11148
  }
10725
11149
  const conversationContext = recentConversation(session)
10726
11150
  if (existing?.plan?.createdTurn === payload.turn) return downstream
@@ -11174,7 +11598,17 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
11174
11598
  * 「先经用户认可再执行」门槛语时同样不自动派发——用户明确认可、主 Agent
11175
11599
  * 调用 dsh_workplan_release 之前,计划只展示、任何派发都被拒。
11176
11600
  */
11177
- const autoDispatched = !planMode && !approvalHeld && options?.autoDispatch !== false
11601
+ /*
11602
+ * [3.0.6][复审修复] SALVAGED 计划禁止自动派发:规划器抢救出的残缺计划
11603
+ * (超时/中断截断、仅过部分校验)未经确认直接 startAutoDispatch,等于让
11604
+ * 残缺的部门划分与验收口径在无人复核的情况下生效。这里把 outcome 纳入
11605
+ * 派发判据,SALVAGED 时改为下发一条用户可见通知(见下方 deliver 分支),
11606
+ * 确认后再由主 Agent 显式 dsh_workplan_dispatch。autoResume 链路不构成
11607
+ * 渗透点:armAutoResume 只在 finishRound(一轮派发结束后)触发,从未派发
11608
+ * 的 SALVAGED 记录进不了那条路径。
11609
+ */
11610
+ const plannerSalvaged = plannerTelemetry.outcome === 'SALVAGED'
11611
+ const autoDispatched = !planMode && !approvalHeld && options?.autoDispatch !== false && !plannerSalvaged
11178
11612
  /*
11179
11613
  * Plan-first: commit the plan with this step and let the main Agent call
11180
11614
  * dsh_workplan_dispatch. Dispatching here would hide the plan until every
@@ -11236,6 +11670,28 @@ async function maybePlan(ctx: any, state: any, payload: any, downstream: any, op
11236
11670
  // [T7] C3 整轮预算:自动派发同样重置(与显式派发同口径)。
11237
11671
  resetRoundInjectionBudget(session, `${record.plan.planId}:${record.dispatchedAt}`)
11238
11672
  state.startAutoDispatch?.(record, session, payload.agent)
11673
+ } else if (plannerSalvaged) {
11674
+ /*
11675
+ * [3.0.6][复审修复] 残缺计划的暂停通知:计划照展示(用户需要看到抢救
11676
+ * 结果),但什么都不开跑。计划级留痕进 record.errors,随 durable 回放
11677
+ * 不丢;用户确认后由主 Agent 显式 dispatch。
11678
+ */
11679
+ record.errors = [...(record.errors ?? []),
11680
+ '规划器只抢救出残缺计划(outcome=SALVAGED),已暂停自动执行;请人工确认后再 workplan_dispatch。'].slice(-20)
11681
+ deliver([
11682
+ makeUserMessage(
11683
+ [
11684
+ '⚠️ 规划器只抢救出残缺计划:模型输出在超时/中断前被截断,仅通过部分校验。',
11685
+ '为避免残缺计划在无人复核的情况下直接执行,本次已暂停自动派发。',
11686
+ '请人工核对该计划:确认可用后告知主 Agent 调用 dsh_workplan_dispatch 开跑;不可用可要求重新分解。',
11687
+ ].join('\n'),
11688
+ {
11689
+ kind: 'workplan-salvaged',
11690
+ form: 'notice',
11691
+ summary: '规划器只抢救出残缺计划,已暂停自动执行,请确认后再 workplan_dispatch',
11692
+ },
11693
+ ),
11694
+ ])
11239
11695
  }
11240
11696
  return
11241
11697
  }