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/CHANGELOG.md +58 -0
- package/README.en.md +15 -7
- package/README.md +18 -8
- package/README.zh.md +8 -7
- package/client.js +181 -27
- package/docs/release-notes-3.0.3.md +7 -0
- package/lib/approval-gate.js +79 -3
- package/lib/client.js +181 -27
- package/lib/comm-format.js +11 -9
- package/lib/dept-journal.js +223 -6
- package/lib/host.js +215 -12
- package/lib/lessons.js +83 -15
- package/lib/llm-rules.js +3 -2
- package/lib/notice-ledger.js +238 -0
- package/lib/plan.js +122 -5
- package/lib/runtime.js +446 -34
- package/lib/three-phase.js +78 -25
- package/lib/understanding.js +85 -6
- package/lib/v3-contract.js +45 -12
- package/package.json +1 -1
- package/src/approval-gate.ts +77 -3
- package/src/client.ts +178 -24
- package/src/comm-format.ts +10 -9
- package/src/dept-journal.ts +219 -7
- package/src/host.ts +215 -12
- package/src/lessons.ts +88 -15
- package/src/llm-rules.ts +3 -2
- package/src/notice-ledger.ts +251 -0
- package/src/plan.ts +126 -5
- package/src/runtime.ts +488 -32
- package/src/three-phase.ts +96 -27
- package/src/understanding.ts +100 -6
- package/src/v3-contract.ts +46 -13
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
|
|
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-
|
|
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-
|
|
7184
|
-
?
|
|
7185
|
-
:
|
|
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: '
|
|
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
|
-
? {
|
|
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
|
|
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
|
-
:
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
9870
|
-
|
|
9871
|
-
|
|
9872
|
-
|
|
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
|
|
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
|
|
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
|
-
|
|
10516
|
-
|
|
10517
|
-
if (body
|
|
10518
|
-
|
|
10519
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
}
|