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/lib/runtime.js CHANGED
@@ -233,6 +233,59 @@ export function describeSubagentActivationError(error, context) {
233
233
  }
234
234
  return error instanceof Error ? error : new Error(raw || String(error));
235
235
  }
236
+ /**
237
+ * [3.0.6][第 2 批] 宿主并发上限的“排队”而不是“判失败”。
238
+ *
239
+ * 宿主 `maxActiveSubagents`(默认 8)按**整棵会话树**共享;插件三层体系
240
+ * (5 个负责人 + 每人再派专家)很容易在某一刻撞上限。旧实现把
241
+ * `ACTIVATION_LIMIT_REACHED` 当普通失败:重试一次仍满就整行 `blocked`,
242
+ * 用户什么都没做错却看到“任务失败”。
243
+ *
244
+ * 现在在 `startActivation` 外层做**有界等待**:撞上限就退避后再试,直到
245
+ * 有空位、被取消、或等满 {@link ACTIVATION_QUEUE_MAX_WAIT_MS}。等待期间
246
+ * 不写失败状态、不消耗子任务 attempt;只有等满才如实报“仍未等到空位”。
247
+ *
248
+ * 多个等待者共享一个模块级冷却时间,避免同一毫秒一起撞门(惊群)。
249
+ * 这不是“精确信号量”(宿主没有暴露当前活跃数),而是“有界排队退避”:
250
+ * 空位一出现,等待者按退避节奏自然补位。
251
+ */
252
+ export const ACTIVATION_QUEUE_MAX_WAIT_MS = 10 * 60 * 1000;
253
+ const ACTIVATION_QUEUE_BASE_DELAY_MS = 1000;
254
+ const ACTIVATION_QUEUE_MAX_DELAY_MS = 15000;
255
+ let activationQueueCooldownUntil = 0;
256
+ export function isActivationLimitError(error) {
257
+ if (String(error?.code ?? '') === 'ACTIVATION_LIMIT_REACHED')
258
+ return true;
259
+ return /limit reached/i.test(String(error?.message ?? error ?? ''));
260
+ }
261
+ export async function startActivationQueued(start, signal, context) {
262
+ const beganAt = Date.now();
263
+ let waits = 0;
264
+ for (;;) {
265
+ try {
266
+ return await start();
267
+ }
268
+ catch (error) {
269
+ if (!isActivationLimitError(error))
270
+ throw error;
271
+ if (signal?.aborted)
272
+ throw new PlanError('排队等待子代理空位时被取消', 'ABORTED');
273
+ const elapsed = Date.now() - beganAt;
274
+ if (elapsed >= ACTIVATION_QUEUE_MAX_WAIT_MS) {
275
+ throw describeSubagentActivationError(error, `${context}:已排队等待 ${Math.round(elapsed / 1000)} 秒仍未等到空位`);
276
+ }
277
+ waits += 1;
278
+ const backoff = Math.min(ACTIVATION_QUEUE_MAX_DELAY_MS, ACTIVATION_QUEUE_BASE_DELAY_MS * 2 ** Math.min(4, waits - 1));
279
+ const now = Date.now();
280
+ // 全局冷却只增不减:所有等待者共用同一个“下一次可以再试”的时刻。
281
+ activationQueueCooldownUntil = Math.max(activationQueueCooldownUntil, now + backoff);
282
+ const delay = Math.max(250, activationQueueCooldownUntil - now);
283
+ await sleepAbortable(signal, delay + Math.floor(Math.random() * 250));
284
+ if (signal?.aborted)
285
+ throw new PlanError('排队等待子代理空位时被取消', 'ABORTED');
286
+ }
287
+ }
288
+ }
236
289
  export function deriveReportPending(record) {
237
290
  const statuses = Array.isArray(record?.statuses) ? record.statuses : [];
238
291
  /*
@@ -436,6 +489,13 @@ export const DISPOSE_TIMEOUT_MS = 5000;
436
489
  export const STALE_PENDING_MS = 10 * 60 * 1000;
437
490
  export const MAX_HISTORY_EVENTS = 2000;
438
491
  export const MAX_LIVE_SESSIONS = 20;
492
+ /**
493
+ * 看板响应上限按**字节**计,而不是 JavaScript 字符串长度。
494
+ * UTF-8 下一个汉字通常 3 字节:旧实现用 `body.length > 2_500_000`,中文响应
495
+ * 实际可发出约 7.5MB,远超注释承诺的 2.5MB。截断后也必须复检,否则 12 个
496
+ * 会话仍可能超限。
497
+ */
498
+ export const MAX_PLANS_RESPONSE_BYTES = 2_500_000;
439
499
  function abortError() {
440
500
  return new PlanError('执行已取消', 'ABORTED');
441
501
  }
@@ -2302,7 +2362,7 @@ async function executeSubtask(ctx, record, stage, subtask, options) {
2302
2362
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(不阻断派发)。
2303
2363
  notifyDepthOverrideConflict(ctx, typeof record?.plan?.sessionId === 'string' ? record.plan.sessionId : null);
2304
2364
  try {
2305
- activation = await ctx.subagents.startActivation({
2365
+ activation = await startActivationQueued(() => ctx.subagents.startActivation({
2306
2366
  provider: 'spawn',
2307
2367
  label: `${subtask.department}:${subtask.id} ${subtask.title}`.slice(0, 120),
2308
2368
  prompt: [{
@@ -2409,7 +2469,7 @@ async function executeSubtask(ctx, record, stage, subtask, options) {
2409
2469
  maxDepth: 2,
2410
2470
  signal: child.controller.signal,
2411
2471
  delivery: 'caller',
2412
- });
2472
+ }), child.controller.signal, `派发子任务 ${subtask.id}(${subtask.title})`);
2413
2473
  }
2414
2474
  catch (error) {
2415
2475
  // [3.0.1][P1b] 并发上限翻译为可行动提示;其余错误原样上抛(保持旧行为)。
@@ -4725,6 +4785,40 @@ export function reconstructFromSession(session, targetPlanId) {
4725
4785
  }
4726
4786
  const plan = chosen.plan;
4727
4787
  const statuses = chosen.statuses;
4788
+ /*
4789
+ * [3.0.6][复审修复] 僵尸 in_progress 回收:派发中途进程死亡 → 重启 → 回放
4790
+ * 重建出的行永远停在「正在做」,但没有任何存活 dispatchPromise 在调度它们
4791
+ * (canResumePlan 又只对 executing 放行,结果只能人工逐行改判)。重建路径
4792
+ * 天然不存在运行期派发,因此把残留的 in_progress 降级为 blocked:
4793
+ * 既有 resetBlockedStatuses/dispatch 路径即可正常接管续跑。行级 error 沿用
4794
+ * 本文件 settleStaleInflight(1.8.4)的同款收束写法:保留原说明、缺说明补
4795
+ * 一句人话;另往快照 errors 追加一条计划级留痕。运行期 in_progress 不在此
4796
+ * 误伤——那条路由 serialisePlan 的存活信号(dispatchPromise/turnEnded)收敛。
4797
+ *
4798
+ * 只收「还可能被派发」的计划:cancelled/superseded 的行状态是历史留痕
4799
+ * (workplan-255-cancel-replay R2 钉住取消后行状态原样回放),不做改写。
4800
+ * resultSeen 不豁免——暂停在中途的计划(结果消息已写、行停在 in_progress)
4801
+ * 恰恰是事故本体;而真正收尾的计划行全 done,本循环自然空转。
4802
+ */
4803
+ const ZOMBIE_INFLIGHT_ERROR = '重启后失联:派发中断,需重新派发';
4804
+ const zombieRecoveryApplies = !chosen.cancelled && !chosen.superseded;
4805
+ let zombieRecovered = 0;
4806
+ if (zombieRecoveryApplies) {
4807
+ for (const row of statuses) {
4808
+ if (row?.status !== 'in_progress')
4809
+ continue;
4810
+ row.status = 'blocked';
4811
+ if (typeof row.error !== 'string' || row.error.trim() === '')
4812
+ row.error = ZOMBIE_INFLIGHT_ERROR;
4813
+ zombieRecovered += 1;
4814
+ }
4815
+ }
4816
+ if (zombieRecovered > 0) {
4817
+ console.warn(`[dsh-workplan] 回放回收 ${zombieRecovered} 条僵尸 in_progress 行`
4818
+ + `(计划 ${String(plan.planId)},派发中断后进程重启):已降级为 blocked,重新派发即可续跑。`);
4819
+ chosen.errors = [...(chosen.errors ?? []),
4820
+ `${ZOMBIE_INFLIGHT_ERROR}(${zombieRecovered} 项已降级为 blocked,可重新派发续跑)`].slice(-20);
4821
+ }
4728
4822
  const resultPhase = chosen.resultPhase;
4729
4823
  const resultSeen = chosen.resultSeen;
4730
4824
  const resumeCount = chosen.resumeCount;
@@ -4899,6 +4993,63 @@ function respondJson(res, status, payload) {
4899
4993
  }
4900
4994
  res.end(body);
4901
4995
  }
4996
+ /**
4997
+ * 响应超限时逐级收缩:先减会话数,再丢单会话的大块明细,最后只留摘要。
4998
+ * 任何一级都返回**合法 JSON**;宁可少给字段,也不返回半截字符串。
4999
+ */
5000
+ export function trimPlansPayload(payload) {
5001
+ const fits = (value) => Buffer.byteLength(JSON.stringify(value)) <= MAX_PLANS_RESPONSE_BYTES;
5002
+ if (fits(payload))
5003
+ return payload;
5004
+ const original = Array.isArray(payload?.sessions) ? payload.sessions.slice() : [];
5005
+ let sessions = original.slice();
5006
+ let trimmed = { ...payload, truncated: true, sessions };
5007
+ while (!fits(trimmed) && sessions.length > 1) {
5008
+ sessions = sessions.slice(0, Math.max(1, Math.ceil(sessions.length / 2)));
5009
+ trimmed = { ...trimmed, sessions };
5010
+ }
5011
+ if (!fits(trimmed)) {
5012
+ sessions = sessions.map((item) => ({
5013
+ sessionId: item.sessionId,
5014
+ planId: item.planId,
5015
+ title: typeof item.title === 'string' ? truncate(item.title, 200) : item.title,
5016
+ phase: item.phase,
5017
+ suspendedPhase: item.suspendedPhase,
5018
+ endedAt: item.endedAt,
5019
+ stats: item.stats,
5020
+ departments: item.departments,
5021
+ statuses: Array.isArray(item.statuses) ? item.statuses.slice(-50) : [],
5022
+ createdAt: item.createdAt,
5023
+ updatedAt: item.updatedAt,
5024
+ running: item.running,
5025
+ deliveryReady: item.deliveryReady,
5026
+ plan: item.plan ? { planId: item.plan.planId, title: item.plan.title } : null,
5027
+ omittedDetail: true,
5028
+ }));
5029
+ trimmed = { ...trimmed, sessions };
5030
+ }
5031
+ if (!fits(trimmed)) {
5032
+ trimmed = {
5033
+ ...trimmed,
5034
+ sessions: sessions.map((item) => ({
5035
+ sessionId: item.sessionId,
5036
+ planId: item.planId,
5037
+ title: typeof item.title === 'string' ? truncate(item.title, 120) : item.title,
5038
+ phase: item.phase,
5039
+ omittedDetail: true,
5040
+ })),
5041
+ };
5042
+ }
5043
+ // 极端情况(例如单条 title 本身就巨大):只保留会话计数,保证响应仍是合法 JSON。
5044
+ if (!fits(trimmed)) {
5045
+ trimmed = {
5046
+ ...trimmed,
5047
+ sessions: [],
5048
+ omittedSessions: original.length,
5049
+ };
5050
+ }
5051
+ return trimmed;
5052
+ }
4902
5053
  export function createWorkplanRuntime(ctx, options = {}) {
4903
5054
  /*
4904
5055
  * `activeTurns` maps a root session to the turn whose user message carried a
@@ -5011,6 +5162,13 @@ export function createWorkplanRuntime(ctx, options = {}) {
5011
5162
  onSubtaskDone: (recordArg, subtask, verdict) => emitSubtaskDoneNotice(recordArg, session, subtask, verdict),
5012
5163
  };
5013
5164
  record.dispatchStartedAt = Date.now();
5165
+ /*
5166
+ * [3.0.6][第 3 批①] 复用同一 record 再派发时清零等待耗尽标记:否则 auto-resume/
5167
+ * continue/重派之后,onTurnStopping 会把下一回合按"已耗尽"零预算秒放行,
5168
+ * 且 waitExhaustedNotifiedTurn 只按 turn 去重,导致每回合误发 ⏳ 上限通知。
5169
+ */
5170
+ record.turnWaitExhausted = undefined;
5171
+ record.waitExhaustedNotifiedTurn = undefined;
5014
5172
  record.dispatchPromise = dispatchPlan(ctx, record, {
5015
5173
  ...roundOptions,
5016
5174
  signal: controller.signal,
@@ -6274,6 +6432,9 @@ export function createWorkplanRuntime(ctx, options = {}) {
6274
6432
  // 新一轮必须写一条新的结果消息,否则主 Agent 永远看不到自动续跑的结局。
6275
6433
  record.resultWritten = false;
6276
6434
  book.doneBefore = Number(live.stats?.done ?? 0);
6435
+ // [3.0.6][第 3 批①] 自动续跑同样复用原 record:派发前清零等待耗尽标记(同 startAutoDispatch)。
6436
+ record.turnWaitExhausted = undefined;
6437
+ record.waitExhaustedNotifiedTurn = undefined;
6277
6438
  record.dispatchPromise = dispatchPlan(ctx, record, {
6278
6439
  ...base,
6279
6440
  // [2.2.0][T6/O-1a] 自动续跑同样在后台执行:保持完成即时通知。
@@ -6826,6 +6987,27 @@ export function createWorkplanRuntime(ctx, options = {}) {
6826
6987
  record = rebuilt;
6827
6988
  }
6828
6989
  if (!record?.plan) {
6990
+ /*
6991
+ * [T3][M7 在途可见] 计划尚未落盘、但后台自动分解正在进行时,不得误报"没有计划"
6992
+ * (T1 失效分支 F4:在途不可见曾让用户与主 Agent 误判为"分配器无对象、任务未开始",
6993
+ * 正是本次缺陷的直接观感)。返回 PLANNING_IN_FLIGHT,附带已耗时与明确下一步,
6994
+ * 与真正的 NO_PLAN 区分。仅读取 state.planningInFlight,不写任何状态。
6995
+ */
6996
+ const inFlight = state.planningInFlight?.get(session.id);
6997
+ if (inFlight) {
6998
+ /* [R2 修正] ok 取 false,与 NO_PLAN 一致:在途意味着「还没有可用计划」,避免调用方
6999
+ * 把 ok:true 误读为「已有计划」。code=PLANNING_IN_FLIGHT 与 hint 明确区分原因与下一步。 */
7000
+ return {
7001
+ ok: false,
7002
+ code: 'PLANNING_IN_FLIGHT',
7003
+ running: false,
7004
+ version: pluginVersion,
7005
+ runtime: runtimeIdentity(),
7006
+ elapsedMs: Date.now() - Number(inFlight.startedAt ?? Date.now()),
7007
+ error: '',
7008
+ hint: '任务分解进行中,计划生成后会话将自动出现计划;请稍后再查看,或等待分配通知。',
7009
+ };
7010
+ }
6829
7011
  /*
6830
7012
  * [1.8.14] N1/§14.6 step 2: the identity of the loaded build must be
6831
7013
  * answerable even before a plan exists. 1.8.13 returned NO_PLAN with no
@@ -6997,21 +7179,21 @@ export function createWorkplanRuntime(ctx, options = {}) {
6997
7179
  const expectedAcceptance = Array.isArray(found?.subtask?.acceptance) ? found.subtask.acceptance : [];
6998
7180
  const rawPhases = isRecord(args?.phases)
6999
7181
  ? args.phases
7000
- : { planning: args?.planning, execution: args?.execution, verification: args?.verification };
7182
+ : { planning: args?.planning, preparation: args?.preparation, execution: args?.execution, verification: args?.verification };
7001
7183
  const check = validatePhaseEvidence(rawPhases, expectedAcceptance);
7002
7184
  if (!check.ok || !check.phases) {
7003
7185
  const gate = phaseGateFromErrors(check.errors);
7004
7186
  return {
7005
7187
  ok: false,
7006
7188
  passed: false,
7007
- code: gate === 'phase-1-2' ? 'PHASE_GATE' : 'VERIFICATION_INCOMPLETE',
7189
+ code: gate === 'phase-1-3' ? 'PHASE_GATE' : 'VERIFICATION_INCOMPLETE',
7008
7190
  phase: gate,
7009
7191
  planId: record.plan.planId,
7010
7192
  subtaskId: row.subtaskId,
7011
7193
  gaps: check.errors,
7012
- error: gate === 'phase-1-2'
7013
- ? `阶段三核验缺少前两阶段证据:先完成「梳理问题 → 形成可执行思路」并实际执行,再提交阶段三核验。${check.errors.slice(0, 5).join(';')}`
7014
- : `阶段三核验未通过:${check.errors.slice(0, 5).join(';')}`,
7194
+ error: gate === 'phase-1-3'
7195
+ ? `核验缺少前几步证据:先完成「梳理任务 → 研究资源工具方案 → 准备到位 → 执行」并按步写全证据,再提交验证核验。${check.errors.slice(0, 5).join(';')}`
7196
+ : `验证核验未通过:${check.errors.slice(0, 5).join(';')}`,
7015
7197
  };
7016
7198
  }
7017
7199
  return {
@@ -7021,7 +7203,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
7021
7203
  planId: record.plan.planId,
7022
7204
  subtaskId: row.subtaskId,
7023
7205
  summary: phaseSummaryLine(check.phases),
7024
- message: '插件核验通过:三阶段证据齐全、验证全部通过。现在把同一份 phases 写进结果块并提交。',
7206
+ message: '插件核验通过:前四步证据齐全、验证全部通过。现在把同一份 phases 写进结果块,并按第五步以 JSON mode 交回本部门负责人。',
7025
7207
  };
7026
7208
  }
7027
7209
  /**
@@ -7178,7 +7360,14 @@ export function createWorkplanRuntime(ctx, options = {}) {
7178
7360
  const journalInfo = journal.result.ok ? {} : { journal: { ok: false, code: journal.result.code, error: journal.result.error } };
7179
7361
  const revision = Number(row.revision ?? 0) + 1;
7180
7362
  const delegates = (Array.isArray(row.delegates) ? row.delegates : []).map((item) => (item?.childId === member.childId
7181
- ? { ...item, escalation: { question, options, needs, at: now, ...(messageId ? { messageId } : {}), delivery } }
7363
+ ? {
7364
+ ...item,
7365
+ // [3.0.5] 待指示必须显式落在第三层台账:负责人改派闸门与看板都读这个字段。
7366
+ closure: 'escalated',
7367
+ blockedKind: 'escalated',
7368
+ error: question,
7369
+ escalation: { question, options, needs, at: now, ...(messageId ? { messageId } : {}), delivery },
7370
+ }
7182
7371
  : item));
7183
7372
  record.statuses = applyStatus(record.statuses, row.subtaskId, { delegates, revision, updatedBy: 'child' });
7184
7373
  record.updatedAt = now;
@@ -7717,6 +7906,21 @@ export function createWorkplanRuntime(ctx, options = {}) {
7717
7906
  if (memberName && targetSessionId && target.childId !== targetSessionId) {
7718
7907
  return { ok: false, code: 'NOT_DELEGATE', subtaskId, error: 'member 与 sessionId 指向不同成员,拒绝投递' };
7719
7908
  }
7909
+ /*
7910
+ * [3.0.5] 指示只能答复「已经提交请示」的原专家:这从机制上保证用户要求的
7911
+ * 四步闭环——专家先上报问题,负责人梳理全部任务状态并研究方案后,只能把
7912
+ * 解决方案下发给原专家继续执行;不能借 instruct 把未请示成员当作替代人选。
7913
+ */
7914
+ if (!target?.escalation && target?.closure !== 'escalated') {
7915
+ return {
7916
+ ok: false,
7917
+ code: 'NOT_ESCALATED',
7918
+ subtaskId,
7919
+ member: target?.member,
7920
+ error: `第三层成员 ${String(target?.member ?? '?')} 不在待指示状态:只有已提交请示的原专家才能接收指示。`,
7921
+ hint: '若该成员遇阻,先让其调用 dsh_workplan_escalate;待指示期间禁止 review/dispatch/direct 改派给其他专家。',
7922
+ };
7923
+ }
7720
7924
  const childId = typeof target.childId === 'string' ? target.childId : '';
7721
7925
  if (!childId) {
7722
7926
  return { ok: false, code: 'NOT_DELEGATE', subtaskId, member: target.member, error: '该成员没有登记子会话 childId,无法投递指示' };
@@ -7738,7 +7942,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
7738
7942
  // inReplyTo(可选):从留痕回放找该成员最近一条请示消息 id;读失败不阻断投递。
7739
7943
  let inReplyTo = '';
7740
7944
  try {
7741
- const prior = readDeptMessages(record.plan.planId, { kind: 'escalation' });
7945
+ const prior = readDeptMessages(record.plan.planId, { kind: 'escalation', newest: true });
7742
7946
  if (prior.ok) {
7743
7947
  const match = [...prior.messages].reverse().find((m) => m.from?.sessionId === childId && m.subtaskId === subtaskId);
7744
7948
  inReplyTo = match?.id ?? '';
@@ -8415,7 +8619,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
8415
8619
  for (let i = 0; i < 2; i += 1) {
8416
8620
  try {
8417
8621
  // [2.5.5][治本] 第三处 spawn 同口径:spec 顶层契约(prompt/parent/cwd/agentOptions/maxDepth)。
8418
- activation = await ctx.subagents.startActivation({
8622
+ activation = await startActivationQueued(() => ctx.subagents.startActivation({
8419
8623
  provider: 'spawn',
8420
8624
  label: `${row.department}:${subtaskId}→${member.member}(self:${selfEffort})`.slice(0, 120),
8421
8625
  prompt: [{ type: 'text', text: promptText }],
@@ -8434,7 +8638,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
8434
8638
  */
8435
8639
  signal: new AbortController().signal,
8436
8640
  delivery: 'caller',
8437
- });
8641
+ }), undefined, `自配档接续(成员 ${member.member})`);
8438
8642
  break;
8439
8643
  }
8440
8644
  catch (error) {
@@ -8599,6 +8803,30 @@ export function createWorkplanRuntime(ctx, options = {}) {
8599
8803
  const entry = { at: Date.now(), action: gateAction, ok, code: ok ? null : String(code ?? 'UNKNOWN') };
8600
8804
  return persist({ gateAudit: [...prior, entry].slice(-20) });
8601
8805
  };
8806
+ /*
8807
+ * [3.0.5] 用户改进方案 1/2 的硬机制:第三层任何专家进入「待指示」后,部门负责
8808
+ * 人不得借 review/dispatch/direct 把相关问题改派、重派或降级给其他人;必须先
8809
+ * 全面梳理该问题与本部门全部 delegates 执行状态,研究方案后用 dsh_workplan_
8810
+ * instruct 答复原成员,由原成员继续执行。这里硬拒的是「换人/重派」动作,
8811
+ * status 仍放行,保证负责人能看到当前所有任务状态并履行研究义务。
8812
+ */
8813
+ const openEscalations = (Array.isArray(row.delegates) ? row.delegates : [])
8814
+ .filter((item) => Boolean(item?.escalation) || item?.closure === 'escalated');
8815
+ if (openEscalations.length > 0 && ['review', 'dispatch', 'direct'].includes(action)) {
8816
+ const members = openEscalations.map((item) => String(item?.member ?? '?'));
8817
+ recordGate(action, false, 'DELEGATE_ESCALATION_OPEN');
8818
+ return {
8819
+ ok: false,
8820
+ code: 'DELEGATE_ESCALATION_OPEN',
8821
+ subtaskId,
8822
+ members,
8823
+ delegates: row.delegates,
8824
+ error: `第三层已有成员待指示(${members.join('、')}):禁止改派、重派或降级给其他人。`
8825
+ + '必须先全面梳理该成员遇到的问题与本部门全部已派发任务的执行状态,研究形成解决方案后,'
8826
+ + '用 dsh_workplan_instruct 答复原成员;平台会强制由原成员继续执行。',
8827
+ hint: '先用 action="status" 查看全部 delegates;对每位待指示成员执行 dsh_workplan_instruct(subtaskId=本部门行 ID,member=待指示成员)。待指示清零后才允许 review/dispatch/direct。',
8828
+ };
8829
+ }
8602
8830
  if (action === 'status') {
8603
8831
  const delegates = Array.isArray(row.delegates) ? row.delegates : [];
8604
8832
  return {
@@ -8611,6 +8839,8 @@ export function createWorkplanRuntime(ctx, options = {}) {
8611
8839
  // [2.5.4][T3R1] 门禁审计对负责人可见(A3:拒绝/放行记录可复核)。
8612
8840
  gateAudit: Array.isArray(row.gateAudit) ? row.gateAudit : [],
8613
8841
  delegates,
8842
+ // [3.0.5] 待指示成员清单:负责人履行「先梳理全部任务状态」义务的读取面。
8843
+ openEscalations: openEscalations.map((item) => String(item?.member ?? '?')),
8614
8844
  // [T7][lead-decisions J2] 负责人时长聚合:与看板/模型面同一读时派生纯函数
8615
8845
  // (J1 冻结结构;null=无下属分工/replanned 旧行/越界 fail-closed,J8/R8)。
8616
8846
  leaderEstimate: deriveLeaderEstimate(row),
@@ -8623,7 +8853,9 @@ export function createWorkplanRuntime(ctx, options = {}) {
8623
8853
  ? '尚未提交梳理产物:先调用 action="review"(用户要求 4 的硬门禁)。'
8624
8854
  : delegates.length === 0
8625
8855
  ? '梳理产物已登记,可调用 action="dispatch" 正式派发给本部门全球顶尖专家。'
8626
- : '第三层已派发;各下级结论会送回本会话,收齐后汇总核验,再写最终结果块。若有成员 closure=escalated(待指示),必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,不要沉默略过。',
8856
+ : openEscalations.length > 0
8857
+ ? `第三层已有 ${openEscalations.length} 名成员待指示(${openEscalations.map((item) => String(item?.member ?? '?')).join('、')}):按 3.0.5 硬规则禁止 review/dispatch/direct 改派;必须先全面梳理该问题与本部门全部任务状态,研究方案后用 dsh_workplan_instruct 答复原成员,由原成员继续执行。`
8858
+ : '第三层已派发;各下级结论会送回本会话,收齐后汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」:必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。',
8627
8859
  };
8628
8860
  }
8629
8861
  /*
@@ -8903,7 +9135,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
8903
9135
  // [3.0.1][P1a] 宿主 subagent.maxDepth < 2 时一次性告警(scope=计划根会话)。
8904
9136
  notifyDepthOverrideConflict(ctx, typeof parentSession?.header?.parentSession === 'string' ? parentSession.header.parentSession : (typeof parentId === 'string' ? parentId : null));
8905
9137
  // [2.5.5][治本] 同 executeSubtask:spec 顶层契约(prompt/parent/cwd/agentOptions/maxDepth)。
8906
- const activation = await ctx.subagents.startActivation({
9138
+ const activation = await startActivationQueued(() => ctx.subagents.startActivation({
8907
9139
  provider: 'spawn',
8908
9140
  label: `${row.department}:${subtaskId}→${assignment.member}`.slice(0, 120),
8909
9141
  prompt: [{ type: 'text', text: promptText }],
@@ -8920,7 +9152,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
8920
9152
  maxDepth: 2,
8921
9153
  signal,
8922
9154
  delivery: 'caller',
8923
- });
9155
+ }), signal, `派发成员 ${assignment.member}(${subtaskId})`);
8924
9156
  childId = typeof activation?.childId === 'string' ? activation.childId : null;
8925
9157
  if (activation && typeof activation.result?.then === 'function') {
8926
9158
  const settledChildId = childId;
@@ -9009,7 +9241,7 @@ export function createWorkplanRuntime(ctx, options = {}) {
9009
9241
  taskEffort: delegationPlan.taskEffort,
9010
9242
  effortOverride: written?.effortOverride ?? row.effortOverride ?? null,
9011
9243
  ...(rejected.length ? { rejected: rejected.map((item) => ({ member: item.member, error: item.error })) } : {}),
9012
- hint: '第三层已派发(一层下级、叶子层,第四层会被硬拒)。每位全球顶尖专家的完成结论会送回本会话(delivery=caller);收齐后由你汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」(delegates[].closure=escalated):必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。',
9244
+ hint: '第三层已派发(一层下级、叶子层,第四层会被硬拒)。每位全球顶尖专家的完成结论会送回本会话(delivery=caller);收齐后由你汇总核验,再写最终结果块。用 action="status" 查看进度。成员遇阻会经 dsh_workplan_escalate 在你这里落「待指示」(delegates[].closure=escalated):必须当轮用 dsh_workplan_instruct(subtaskId=本部门行 ID,多个成员同时请示时加 member)答复,投递成功后该成员恢复执行。3.0.5 硬规则:任何成员待指示期间,review/dispatch/direct 一律拒绝改派,必须由原成员继续执行。',
9013
9245
  };
9014
9246
  }
9015
9247
  async function dispatchTool(agent, args, signal) {
@@ -9295,6 +9527,9 @@ export function createWorkplanRuntime(ctx, options = {}) {
9295
9527
  notifyCompletion: true,
9296
9528
  onSubtaskDone: (recordArg, subtask, verdict) => emitSubtaskDoneNotice(recordArg, session, subtask, verdict),
9297
9529
  };
9530
+ // [3.0.6][第 3 批①] 人工派发/续派复用原 record:派发前清零等待耗尽标记(同 startAutoDispatch)。
9531
+ record.turnWaitExhausted = undefined;
9532
+ record.waitExhaustedNotifiedTurn = undefined;
9298
9533
  record.dispatchPromise = dispatchPlan(ctx, record, {
9299
9534
  ...roundOptions,
9300
9535
  signal: dispatchController.signal,
@@ -9391,6 +9626,43 @@ export function createWorkplanRuntime(ctx, options = {}) {
9391
9626
  * 只要求按未完成口径如实收尾,所以不会空转。
9392
9627
  */
9393
9628
  const STOP_STEER_LIMIT = 2;
9629
+ /*
9630
+ * [3.0.6][第 3 批①] 收尾等待上限(解析一次,全路径同值)。
9631
+ * ≤0 = 无限等待(旧行为);默认 60 分钟。只约束 turn-stopping 的等待,
9632
+ * 不构成部门/专家的执行时限。
9633
+ */
9634
+ const turnStoppingMaxWaitMs = (() => {
9635
+ const raw = Number(options.turnStoppingMaxWaitMs);
9636
+ return Number.isFinite(raw) && raw > 0 ? raw : 0;
9637
+ })();
9638
+ /**
9639
+ * 带上限地等待一个收尾承诺。capMs<=0 时等同无限等待(旧行为)。
9640
+ * 返回 true = 按时结算;false = 等满上限(调用方决定如何收尾)。
9641
+ * 承诺自身结算后绝不再被本函数消费——由调用方一次性判定。
9642
+ */
9643
+ async function waitTurnPromise(promise, capMs) {
9644
+ if (!(capMs > 0)) {
9645
+ try {
9646
+ await promise;
9647
+ }
9648
+ catch { /* 结算失败已由产出方留痕 */ }
9649
+ return true;
9650
+ }
9651
+ let timer = null;
9652
+ try {
9653
+ const timeout = new Promise((resolve) => {
9654
+ // 收束类计时器:到点即状态转移(等待预算耗尽),禁止 unref
9655
+ // (handle-policy 契约;到点必然被 clearTimeout 或先行触发)。
9656
+ timer = setTimeout(() => resolve('timeout'), capMs);
9657
+ });
9658
+ const outcome = await Promise.race([promise.then(() => 'settled', () => 'settled'), timeout]);
9659
+ return outcome === 'settled';
9660
+ }
9661
+ finally {
9662
+ if (timer)
9663
+ clearTimeout(timer);
9664
+ }
9665
+ }
9394
9666
  function recordReadiness(record) {
9395
9667
  return readinessOf(record);
9396
9668
  }
@@ -9728,6 +10000,10 @@ export function createWorkplanRuntime(ctx, options = {}) {
9728
10000
  * pre-step;若只在那里 supersede,旧规划仍会跑完并迟到交付。官方
9729
10001
  * `agent/inbox/inserted` 在消息进入 live inbox 时即发本事件,因此这里先中止。
9730
10002
  * 内部 workplan 通知、社交/状态/空泛续跑均不取消;同任务重复投递保持幂等。
10003
+ * [T3][M2 取代显式通知] 与 pre-step 取代路径同一缺口:此处只置 superseded +
10004
+ * abort,全程静默,用户看到的就是"任务没分配"且无任何解释。这里补同一条
10005
+ * 用户可见取代通知;alreadySuperseded 守卫保证连续多条新消息只通知一次(幂等),
10006
+ * 且绝不恢复旧计划、绝不写 state.records,避免迟到覆盖新任务占位记录。
9731
10007
  */
9732
10008
  function onInboxInserted(payload) {
9733
10009
  const session = payload?.agent?.session;
@@ -9744,8 +10020,13 @@ export function createWorkplanRuntime(ctx, options = {}) {
9744
10020
  return;
9745
10021
  if (planning.taskText === taskText)
9746
10022
  return;
10023
+ const alreadySuperseded = planning.superseded === true;
9747
10024
  planning.superseded = true;
9748
10025
  planning.controller.abort();
10026
+ if (!alreadySuperseded) {
10027
+ appendUserMessage(session, '【dsh-workplan·任务分解被取代】你上一条任务的后台自动分解已被本条新消息中止,原任务不会自动分配。\n' +
10028
+ '如仍需执行原任务:请重新发送该任务,或说"重新生成计划并执行";也可以让我先手动制定计划给你确认后再执行。');
10029
+ }
9749
10030
  }
9750
10031
  async function onTurnStopping(payload) {
9751
10032
  try {
@@ -9771,11 +10052,19 @@ export function createWorkplanRuntime(ctx, options = {}) {
9771
10052
  */
9772
10053
  let record = state.records.get(session.id) ?? known;
9773
10054
  const planning = state.planningInFlight?.get(session.id);
9774
- if (planning?.promise) {
9775
- try {
9776
- await planning.promise;
10055
+ if (planning?.promise && planning.turnWaitTimedOut !== true) {
10056
+ /*
10057
+ * [3.0.6][第 3 批①] 收尾等待上限:规划在途时最多等
10058
+ * turnStoppingMaxWaitMs(默认 60 分钟;0=无限)。到点不再等,标记
10059
+ * turnWaitTimedOut(同一规划对象只等一次,后续收尾不再重复等待),
10060
+ * 按规划未完成继续走下方既有闸门(有界 steer / fail-closed)。
10061
+ */
10062
+ const settled = await waitTurnPromise(planning.promise, turnStoppingMaxWaitMs);
10063
+ if (!settled) {
10064
+ planning.turnWaitTimedOut = true;
10065
+ ctx.logger?.warn?.(`dsh-workplan: 回合 ${turn} 等待在途规划达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟,`
10066
+ + '按「等待预算耗尽」继续收尾检查(规划仍在后台,完成后的交回逻辑不受影响)');
9777
10067
  }
9778
- catch { /* 后台规划自身已记录降级/错误 */ }
9779
10068
  /*
9780
10069
  * 等待期间若同回合后续 step 已用新任务取代旧规划,本次旧收尾必须退出;
9781
10070
  * 新规划的收尾会自行等待并交回,绝不能在这里消费旧结果或误 steer。
@@ -9811,13 +10100,71 @@ export function createWorkplanRuntime(ctx, options = {}) {
9811
10100
  if (!stopGateApplies(record, session, turn))
9812
10101
  return;
9813
10102
  if (record.dispatchPromise) {
9814
- try {
9815
- await record.dispatchPromise;
10103
+ if (record.turnWaitExhausted) {
10104
+ /*
10105
+ * [3.0.6][第 3 批①] 本轮(及后续回合)已耗尽过等待预算且派发仍在跑:
10106
+ * 不再重复等待,直接走下方「放行但留痕」分支,回合如实收尾。
10107
+ */
9816
10108
  }
9817
- catch {
9818
- /* the failure is already on record.errors; the gate only needs the outcome */
10109
+ else {
10110
+ const settled = await waitTurnPromise(record.dispatchPromise, turnStoppingMaxWaitMs);
10111
+ if (!settled) {
10112
+ record.turnWaitExhausted = { turn, at: Date.now(), waitedMs: turnStoppingMaxWaitMs };
10113
+ record.errors = [...(record.errors ?? []), `回合收尾等待派发达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟(等待预算耗尽,派发仍在后台执行)`].slice(-20);
10114
+ ctx.logger?.warn?.(`dsh-workplan: 回合 ${turn} 等待派发达到上限 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟:`
10115
+ + `计划 ${record.plan?.planId} 仍在后台执行,结果消息会照常落盘`);
10116
+ if (failClosedActive) {
10117
+ throw new PlanError(`等待预算耗尽:回合收尾已连续等待派发超过 ${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟`
10118
+ + `(计划 ${record.plan?.planId} 仍在后台执行,本回合不再等待)。headless 以非零退出码结束,不输出「已完成」结果。`, 'WORKPLAN_WAIT_EXHAUSTED', { planId: record.plan?.planId });
10119
+ }
10120
+ }
10121
+ }
10122
+ if (!record.turnWaitExhausted) {
10123
+ try {
10124
+ await record.dispatchPromise;
10125
+ }
10126
+ catch {
10127
+ /* the failure is already on record.errors; the gate only needs the outcome */
10128
+ }
10129
+ finishRound(record, session);
10130
+ }
10131
+ if (record.turnWaitExhausted) {
10132
+ /*
10133
+ * 等待预算耗尽的放行与 steer 用尽同一套「放行但留痕」语义:
10134
+ * 不 steer(避免再拖住回合)、记 releasedIncomplete、追加 notice。
10135
+ * fail-closed 已在上方抛错,不会走到这里。
10136
+ */
10137
+ const stuck = derivePlanSnapshot(record.statuses);
10138
+ const released = (stuck.statuses ?? [])
10139
+ .filter((item) => item.status !== 'done')
10140
+ .map((item) => String(item.subtaskId));
10141
+ record.releasedIncomplete = {
10142
+ turn,
10143
+ at: Date.now(),
10144
+ done: stuck.stats.done,
10145
+ total: stuck.stats.total,
10146
+ remaining: released,
10147
+ reason: 'wait-exhausted',
10148
+ };
10149
+ try {
10150
+ if (record.waitExhaustedNotifiedTurn !== turn) {
10151
+ record.waitExhaustedNotifiedTurn = turn;
10152
+ appendUserMessage(session, makeUserMessage([
10153
+ `⏳ 本轮等待派发已达上限(${Math.round(turnStoppingMaxWaitMs / 60000)} 分钟),按计划仍在后台执行,本回合先行收尾(计划 ${record.plan.planId})`,
10154
+ `进度 ${stuck.stats.done}/${stuck.stats.total};未完成:${released.join(', ') || '无'}`,
10155
+ '后台结果照常落盘:稍后可用 dsh_workplan_status 查看,或在下一回合继续。',
10156
+ ].join('\n'), {
10157
+ kind: 'workplan-release',
10158
+ form: 'notice',
10159
+ summary: `等待预算耗尽放行 ${stuck.stats.done}/${stuck.stats.total}`,
10160
+ }));
10161
+ }
10162
+ }
10163
+ catch (error) {
10164
+ ctx.logger?.warn?.(`dsh-workplan: 等待耗尽放行留痕写入失败:${error instanceof Error ? error.message : String(error)}`);
10165
+ }
10166
+ return;
9819
10167
  }
9820
- finishRound(record, session);
9821
10168
  if (!stopGateApplies(record, session, turn))
9822
10169
  return;
9823
10170
  }
@@ -9913,8 +10260,10 @@ export function createWorkplanRuntime(ctx, options = {}) {
9913
10260
  /*
9914
10261
  * [1.12.3] fail-closed 的硬失败必须穿过这层日志包装:
9915
10262
  * 这里原本把任何异常降级成一条 warn,等于把上面的抛错又吃掉。
10263
+ * [3.0.6] WORKPLAN_WAIT_EXHAUSTED 同属硬失败(等待预算耗尽),同样必须穿透。
9916
10264
  */
9917
- if (error instanceof PlanError && error.code === 'WORKPLAN_INCOMPLETE')
10265
+ if (error instanceof PlanError
10266
+ && (error.code === 'WORKPLAN_INCOMPLETE' || error.code === 'WORKPLAN_WAIT_EXHAUSTED'))
9918
10267
  throw error;
9919
10268
  ctx.logger?.warn?.(`dsh-workplan: 回合收尾检查失败:${error instanceof Error ? error.message : String(error)}`);
9920
10269
  }
@@ -10434,8 +10783,17 @@ export function createWorkplanRuntime(ctx, options = {}) {
10434
10783
  async function route(req, res, connectionCtx = ctx) {
10435
10784
  applyHardeningHeaders(res);
10436
10785
  let rejection;
10786
+ /*
10787
+ * 鉴权 fail-closed:connection 服务存在但没有 requestRejection(宿主 API 改名/降级)时,
10788
+ * 旧实现会因可选链返回 undefined 而直接放行,等于把全部会话计划暴露给未鉴权请求。
10789
+ * 看板是敏感数据路由,宁可直接拒绝,也不能在“检查器不见了”时默认通过。
10790
+ */
10791
+ if (typeof connectionCtx?.connection?.requestRejection !== 'function') {
10792
+ respondJson(res, 503, { ok: false, error: '鉴权服务不可用,已拒绝访问' });
10793
+ return;
10794
+ }
10437
10795
  try {
10438
- rejection = await Promise.resolve(connectionCtx?.connection?.requestRejection?.(req));
10796
+ rejection = await Promise.resolve(connectionCtx.connection.requestRejection(req));
10439
10797
  }
10440
10798
  catch {
10441
10799
  respondJson(res, 403, { ok: false, error: '未授权的请求' });
@@ -10466,11 +10824,11 @@ export function createWorkplanRuntime(ctx, options = {}) {
10466
10824
  return;
10467
10825
  }
10468
10826
  try {
10469
- const payload = plansPayload(url.searchParams.get('sessionId') ?? undefined);
10470
- const body = JSON.stringify(payload);
10471
- if (body.length > 2_500_000) {
10472
- respondJson(res, 200, { ...payload, truncated: true, sessions: payload.sessions.slice(0, 12) });
10473
- return;
10827
+ let payload = plansPayload(url.searchParams.get('sessionId') ?? undefined);
10828
+ let body = JSON.stringify(payload);
10829
+ if (Buffer.byteLength(body) > MAX_PLANS_RESPONSE_BYTES) {
10830
+ payload = trimPlansPayload(payload);
10831
+ body = JSON.stringify(payload);
10474
10832
  }
10475
10833
  if (req.method === 'HEAD') {
10476
10834
  res.writeHead(200, {
@@ -10501,7 +10859,19 @@ export function createWorkplanRuntime(ctx, options = {}) {
10501
10859
  * 用户要求这些经验必须能被复核。主 Agent 在阶段三可以用它查:记住了什么、
10502
10860
  * 哪些同类错误在重复发生、文件到底写在哪。它只读文件,不改任何计划状态。
10503
10861
  */
10504
- async function lessonsTool(_agent, args) {
10862
+ /*
10863
+ * [3.0.6][复审修复] 数据面越权:lessons.jsonl 是跨项目的全局永久记忆(含
10864
+ * 其它项目 cwd 与问题描述),此前无任何会话校验,任意子 Agent(含其它插件
10865
+ * 拉起的子会话)都能读走。这里与其它工具(update/replan/cancel 等)同一
10866
+ * 写法加 isRootSession 硬校验:非根会话直接抛权限错误,不依赖提示词约束;
10867
+ * 根会话行为不变。
10868
+ */
10869
+ async function lessonsTool(agent, args) {
10870
+ const session = agent?.session;
10871
+ if (!session)
10872
+ throw new PlanError('只能在会话内查询永久教训记忆', 'NO_SESSION');
10873
+ if (!isRootSession(session))
10874
+ throw new PlanError('子 Agent 不能读取全局永久教训记忆', 'NOT_ROOT');
10505
10875
  const parsed = isRecord(args) ? args : {};
10506
10876
  const action = String(parsed.action ?? 'list');
10507
10877
  const file = resolveLessonsFile();
@@ -10681,8 +11051,20 @@ async function maybePlan(ctx, state, payload, downstream, options) {
10681
11051
  if (priorPlanning) {
10682
11052
  if (priorPlanning.taskText === taskText)
10683
11053
  return downstream;
11054
+ /*
11055
+ * [T3][M2 取代显式通知] 原任务的后台自动分解被本条新消息取代。T1 根因:此处置旧规划
11056
+ * 只置 superseded + abort,全程静默,用户看到的就是"任务没分配"且无任何解释。这里补一条
11057
+ * 用户可见降级通知。边界沿用 11099 注释的防御意图:绝不恢复旧计划、绝不写 state.records
11058
+ * (避免迟到覆盖新任务占位记录);通知只走 appendUserMessage(与规划预告/心跳同一合规
11059
+ * 写入器)。alreadySuperseded 守卫保证连续多条新消息只在首次取代时通知一次(幂等)。
11060
+ */
11061
+ const alreadySuperseded = priorPlanning.superseded === true;
10684
11062
  priorPlanning.superseded = true;
10685
11063
  priorPlanning.controller.abort();
11064
+ if (!alreadySuperseded) {
11065
+ appendUserMessage(session, '【dsh-workplan·任务分解被取代】你上一条任务的后台自动分解已被本条新消息中止,原任务不会自动分配。\n' +
11066
+ '如仍需执行原任务:请重新发送该任务,或说"重新生成计划并执行";也可以让我先手动制定计划给你确认后再执行。');
11067
+ }
10686
11068
  }
10687
11069
  const conversationContext = recentConversation(session);
10688
11070
  if (existing?.plan?.createdTurn === payload.turn)
@@ -11143,7 +11525,17 @@ async function maybePlan(ctx, state, payload, downstream, options) {
11143
11525
  * 「先经用户认可再执行」门槛语时同样不自动派发——用户明确认可、主 Agent
11144
11526
  * 调用 dsh_workplan_release 之前,计划只展示、任何派发都被拒。
11145
11527
  */
11146
- const autoDispatched = !planMode && !approvalHeld && options?.autoDispatch !== false;
11528
+ /*
11529
+ * [3.0.6][复审修复] SALVAGED 计划禁止自动派发:规划器抢救出的残缺计划
11530
+ * (超时/中断截断、仅过部分校验)未经确认直接 startAutoDispatch,等于让
11531
+ * 残缺的部门划分与验收口径在无人复核的情况下生效。这里把 outcome 纳入
11532
+ * 派发判据,SALVAGED 时改为下发一条用户可见通知(见下方 deliver 分支),
11533
+ * 确认后再由主 Agent 显式 dsh_workplan_dispatch。autoResume 链路不构成
11534
+ * 渗透点:armAutoResume 只在 finishRound(一轮派发结束后)触发,从未派发
11535
+ * 的 SALVAGED 记录进不了那条路径。
11536
+ */
11537
+ const plannerSalvaged = plannerTelemetry.outcome === 'SALVAGED';
11538
+ const autoDispatched = !planMode && !approvalHeld && options?.autoDispatch !== false && !plannerSalvaged;
11147
11539
  /*
11148
11540
  * Plan-first: commit the plan with this step and let the main Agent call
11149
11541
  * dsh_workplan_dispatch. Dispatching here would hide the plan until every
@@ -11204,6 +11596,26 @@ async function maybePlan(ctx, state, payload, downstream, options) {
11204
11596
  resetRoundInjectionBudget(session, `${record.plan.planId}:${record.dispatchedAt}`);
11205
11597
  state.startAutoDispatch?.(record, session, payload.agent);
11206
11598
  }
11599
+ else if (plannerSalvaged) {
11600
+ /*
11601
+ * [3.0.6][复审修复] 残缺计划的暂停通知:计划照展示(用户需要看到抢救
11602
+ * 结果),但什么都不开跑。计划级留痕进 record.errors,随 durable 回放
11603
+ * 不丢;用户确认后由主 Agent 显式 dispatch。
11604
+ */
11605
+ record.errors = [...(record.errors ?? []),
11606
+ '规划器只抢救出残缺计划(outcome=SALVAGED),已暂停自动执行;请人工确认后再 workplan_dispatch。'].slice(-20);
11607
+ deliver([
11608
+ makeUserMessage([
11609
+ '⚠️ 规划器只抢救出残缺计划:模型输出在超时/中断前被截断,仅通过部分校验。',
11610
+ '为避免残缺计划在无人复核的情况下直接执行,本次已暂停自动派发。',
11611
+ '请人工核对该计划:确认可用后告知主 Agent 调用 dsh_workplan_dispatch 开跑;不可用可要求重新分解。',
11612
+ ].join('\n'), {
11613
+ kind: 'workplan-salvaged',
11614
+ form: 'notice',
11615
+ summary: '规划器只抢救出残缺计划,已暂停自动执行,请确认后再 workplan_dispatch',
11616
+ }),
11617
+ ]);
11618
+ }
11207
11619
  return;
11208
11620
  }
11209
11621
  /*