agentworkshop 0.7.53 → 0.7.58

package/server/services/workshop/runtime/memory/write.ts

@@ -1,93 +1,149 @@
-/**
- * AgentMemoryWrite —— 写入:save / 任务结果 / peer 交换 / 向量化
- * (拆分层,承 AgentMemoryRecall;方法体与原文件逐行一致)
- */
-import { AgentMemoryRecall } from './recall'
-import type { A2AMessage } from '../../types/a2a'
-import type { WorkspaceTask } from '../../types/task'
-import { CONTENT_STORE_LIMIT, partsText, segmentCJK, vectorizeMemory } from './helpers'
-import { TEAM_AGENT_ID } from '../../db/memory.repo'
-import { randomUUID } from 'node:crypto'
-
-export abstract class AgentMemoryWrite extends AgentMemoryRecall {
-  /**
-   * Agent 主动沉淀(save_memory 工具):把作业过程中的可复用结论/经验写入记忆库。
-   * scope='private' → 本人 semantic 域;scope='shared' → Channel 公共域(全员可检索;
-   * dedupKey 按来源 Agent 命名空间隔离,避免多 Agent 同 key 互相覆盖)。写入后自动向量化。
-   */
-  async save(input: { title: string, content: string, importance?: number, scope: 'private' | 'shared', dedupKey?: string }): Promise<{ scope: 'private' | 'shared', dedupKey: string }> {
-    const shared = input.scope === 'shared'
-    const rawKey = input.dedupKey?.trim() || `agent-save:${randomUUID().slice(0, 8)}`
-    // 共享域命名空间:同 channel 多 agent 各自的沉淀互不覆盖
-    const dedupKey = shared ? `agent:${this.opts.agentId}:${rawKey}` : rawKey
-    const owner = shared ? TEAM_AGENT_ID : this.opts.agentId
-    this.repo.upsert({
-      channelId: this.opts.channelId,
-      agentId: owner,
-      kind: 'semantic',
-      title: input.title,
-      titleFts: segmentCJK(input.title),
-      content: segmentCJK(input.content).slice(0, CONTENT_STORE_LIMIT),
-      importance: input.importance ?? (shared ? 0.85 : 0.7),
-      taskId: null,
-      dedupKey,
-    })
-    await vectorizeMemory(this.repo, this.embedder, this.opts.channelId, owner, dedupKey, input.content)
-    // 共享约定进入简报"团队共享约定"行
-    if (shared) await this.updateBrief()
-    return { scope: input.scope, dedupKey }
-  }
-
-  /** run 后(任务路径;仅终态调用):harvest TaskEngine 终态 + deliverable,并刷新 L0 简报 */
-  async recordTaskOutcome(task: WorkspaceTask): Promise<void> {
-    // 优先 deliverable/summary 命名成果;harness 任意命名(如 mock 的 result)兜底取全部成果
-    const preferred = task.artifacts.filter(a => a.name === 'deliverable' || a.name === 'summary')
-    const source = preferred.length > 0 ? preferred : task.artifacts
-    const deliverable = source
-      .flatMap(a => a.parts)
-      .map(p => ('text' in p ? p.text : ''))
-      .join(' ')
-      .trim()
-    const content = deliverable || task.description || task.title
-    this.repo.upsert({
-      channelId: this.opts.channelId,
-      agentId: this.opts.agentId,
-      kind: 'episodic-task',
-      title: task.title,
-      titleFts: segmentCJK(task.title),
-      content: segmentCJK(content).slice(0, CONTENT_STORE_LIMIT),
-      importance: task.state === 'COMPLETED' ? 0.8 : 0.55,
-      taskId: task.id,
-      dedupKey: `task:${task.id}`,
-    })
-    await this.vectorize(content, `task:${task.id}`)
-    await this.updateBrief()
-  }
-
-  /** run 后(点对点路径):请求 + 我方回复摘要 */
-  async recordPeerExchange(msg: A2AMessage, replyText: string): Promise<void> {
-    const ask = partsText(msg.parts).slice(0, 150)
-    const content = replyText ? `问:${ask} 答:${replyText.slice(0, 250)}` : ask
-    const fromId = (msg.metadata?.['x-aw-from-agent'] as string | undefined) ?? 'unknown'
-    const title = `来自 ${fromId} 的消息`
-    this.repo.upsert({
-      channelId: this.opts.channelId,
-      agentId: this.opts.agentId,
-      kind: 'episodic-peer',
-      title,
-      titleFts: segmentCJK(title),
-      content: segmentCJK(content).slice(0, 600),
-      importance: 0.4,
-      taskId: msg.taskId ?? null,
-      dedupKey: `peer:${msg.messageId}`,
-    })
-    await this.vectorize(content, `peer:${msg.messageId}`)
-  }
-
-  /** 写入后向量化(委托模块级 vectorizeMemory;未切分原文,失败静默留 FTS) */
-  protected async vectorize(plainContent: string, dedupKey: string): Promise<void> {
-    await vectorizeMemory(this.repo, this.embedder, this.opts.channelId, this.opts.agentId, dedupKey, plainContent)
-  }
-
-  // ===== 上下文治理/团队历史(P0-3 新增写入面;全部幂等 upsert)=====
-}
+/**
+ * AgentMemoryWrite —— 写入:save / 任务结果 / peer 交换 / 向量化
+ * (拆分层,承 AgentMemoryRecall;方法体与原文件逐行一致)
+ */
+import { AgentMemoryRecall } from './recall'
+import type { A2AMessage } from '../../types/a2a'
+import type { WorkspaceTask } from '../../types/task'
+import { CONTENT_STORE_LIMIT, buildMatchQuery, partsText, segmentCJK, unsegmentCJK, vectorizeMemory } from './helpers'
+import { TEAM_AGENT_ID } from '../../db/memory.repo'
+import { randomUUID } from 'node:crypto'
+
+export abstract class AgentMemoryWrite extends AgentMemoryRecall {
+  /**
+   * Agent 主动沉淀(save_memory 工具):把作业过程中的可复用结论/经验写入记忆库。
+   * scope='private' → 本人 semantic 域;scope='shared' → Channel 公共域(全员可检索;
+   * dedupKey 按来源 Agent 命名空间隔离,避免多 Agent 同 key 互相覆盖)。写入后自动向量化。
+   */
+  async save(input: { title: string, content: string, importance?: number, scope: 'private' | 'shared', dedupKey?: string }): Promise<{ scope: 'private' | 'shared', dedupKey: string }> {
+    const shared = input.scope === 'shared'
+    const rawKey = input.dedupKey?.trim() || `agent-save:${randomUUID().slice(0, 8)}`
+    // 共享域命名空间:同 channel 多 agent 各自的沉淀互不覆盖
+    const dedupKey = shared ? `agent:${this.opts.agentId}:${rawKey}` : rawKey
+    const owner = shared ? TEAM_AGENT_ID : this.opts.agentId
+    // 共享域近邻治理(2026-10-05 记忆治理最小版):同一事实多 agent 各写一条永不合并
+    // (lead ~1.0 与 worker ~0.09 并存靠当场甄别)。写入前查共享域近邻:
+    //   标题高度重合 + 数值一致 → 并入既有条目(追加并存来源,不新建);
+    //   数值矛盾 → 新条目标 [contested](两条并存,矛盾显式化)。
+    let title = input.title
+    const content = input.content
+    let finalKey = dedupKey
+    if (shared) {
+      // 近邻检索必须走 buildMatchQuery:标题原文直喂 FTS5 时,`10:30`/`2026-10-07` 这类
+      // "数字:数字/含:+-"片段会被解析成列过滤器/短语算子 → "no such column: 10"
+      // (实测:跨频道冻结约定标题含时间戳,save_memory 全量炸掉)。
+      const matchQuery = buildMatchQuery(input.title)
+      const near = matchQuery
+        ? this.repo.search(TEAM_AGENT_ID, matchQuery, 3).filter(r => r.kind === 'semantic')
+        : []
+      const tokensOf = (t: string) => new Set(segmentCJK(t).split(/\s+/).filter(Boolean))
+      const jaccard = (a: Set<string>, b: Set<string>) => {
+        const inter = [...a].filter(x => b.has(x)).length
+        return inter / Math.max(1, a.size + b.size - inter)
+      }
+      const numsOf = (t: string) => (t.match(/-?\d+(?:\.\d+)?/g) ?? []).map(Number)
+      for (const row of near) {
+        if (jaccard(tokensOf(input.title), tokensOf(row.title)) < 0.75) continue
+        const oldContent = unsegmentCJK(String(row.content ?? ''))
+        const oldNums = numsOf(oldContent)
+        const newNums = numsOf(input.content)
+        const numbersAgree = oldNums.length > 0
+          && oldNums.length === newNums.length
+          && oldNums.every((v, i) => {
+            const w = newNums[i] ?? Number.NaN
+            return Math.abs(v - w) <= Math.max(1e-6, Math.abs(v) * 0.01)
+          })
+        if (numbersAgree) {
+          const confirmNote = `[并存确认 ${this.opts.agentId} @${new Date().toISOString().slice(0, 16)}]`
+          const merged = `${oldContent}${confirmNote}`
+          const mergedTitleFts = row.titleFts ?? segmentCJK(row.title)
+          const mergedDedup = row.dedupKey ?? `legacy:${row.id}`
+          this.repo.upsert({
+            channelId: row.channelId,
+            agentId: row.agentId,
+            kind: row.kind,
+            title: row.title,
+            titleFts: mergedTitleFts,
+            content: segmentCJK(merged).slice(0, CONTENT_STORE_LIMIT),
+            importance: Math.min(1, (row.importance ?? 0.8) + 0.05),
+            taskId: row.taskId,
+            dedupKey: mergedDedup,
+          })
+          await vectorizeMemory(this.repo, this.embedder, this.opts.channelId, row.agentId, mergedDedup, merged)
+          return { scope: input.scope, dedupKey: mergedDedup }
+        }
+        title = `[contested:${row.id.slice(0, 8)}] ${title}`
+        finalKey = `${dedupKey}:contested`
+        break
+      }
+    }
+    this.repo.upsert({
+      channelId: this.opts.channelId,
+      agentId: owner,
+      kind: 'semantic',
+      title,
+      titleFts: segmentCJK(title),
+      content: segmentCJK(content).slice(0, CONTENT_STORE_LIMIT),
+      importance: input.importance ?? (shared ? 0.85 : 0.7),
+      taskId: null,
+      dedupKey: finalKey,
+    })
+    await vectorizeMemory(this.repo, this.embedder, this.opts.channelId, owner, finalKey, content)
+    // 共享约定进入简报"团队共享约定"行
+    if (shared) await this.updateBrief()
+    return { scope: input.scope, dedupKey: finalKey }
+  }
+
+  /** run 后(任务路径;仅终态调用):harvest TaskEngine 终态 + deliverable,并刷新 L0 简报 */
+  async recordTaskOutcome(task: WorkspaceTask): Promise<void> {
+    // 优先 deliverable/summary 命名成果;harness 任意命名(如 mock 的 result)兜底取全部成果
+    const preferred = task.artifacts.filter(a => a.name === 'deliverable' || a.name === 'summary')
+    const source = preferred.length > 0 ? preferred : task.artifacts
+    const deliverable = source
+      .flatMap(a => a.parts)
+      .map(p => ('text' in p ? p.text : ''))
+      .join(' ')
+      .trim()
+    const content = deliverable || task.description || task.title
+    this.repo.upsert({
+      channelId: this.opts.channelId,
+      agentId: this.opts.agentId,
+      kind: 'episodic-task',
+      title: task.title,
+      titleFts: segmentCJK(task.title),
+      content: segmentCJK(content).slice(0, CONTENT_STORE_LIMIT),
+      importance: task.state === 'COMPLETED' ? 0.8 : 0.55,
+      taskId: task.id,
+      dedupKey: `task:${task.id}`,
+    })
+    await this.vectorize(content, `task:${task.id}`)
+    await this.updateBrief()
+  }
+
+  /** run 后(点对点路径):请求 + 我方回复摘要 */
+  async recordPeerExchange(msg: A2AMessage, replyText: string): Promise<void> {
+    const ask = partsText(msg.parts).slice(0, 150)
+    const content = replyText ? `问:${ask} 答:${replyText.slice(0, 250)}` : ask
+    const fromId = (msg.metadata?.['x-aw-from-agent'] as string | undefined) ?? 'unknown'
+    const title = `来自 ${fromId} 的消息`
+    this.repo.upsert({
+      channelId: this.opts.channelId,
+      agentId: this.opts.agentId,
+      kind: 'episodic-peer',
+      title,
+      titleFts: segmentCJK(title),
+      content: segmentCJK(content).slice(0, 600),
+      importance: 0.4,
+      taskId: msg.taskId ?? null,
+      dedupKey: `peer:${msg.messageId}`,
+    })
+    await this.vectorize(content, `peer:${msg.messageId}`)
+  }
+
+  /** 写入后向量化(委托模块级 vectorizeMemory;未切分原文,失败静默留 FTS) */
+  protected async vectorize(plainContent: string, dedupKey: string): Promise<void> {
+    await vectorizeMemory(this.repo, this.embedder, this.opts.channelId, this.opts.agentId, dedupKey, plainContent)
+  }
+
+  // ===== 上下文治理/团队历史(P0-3 新增写入面;全部幂等 upsert)=====
+}

package/server/services/workshop/runtime/platform-notice.ts

@@ -0,0 +1,113 @@
+/**
+ * PlatformNotice —— 平台 → Agent 主动通告面。
+ *
+ * 两条链路共用一个投递管道(持久化 mailbox + 空闲唤醒):
+ *  ① 异步工具结果回执:后台作业(AML 训练/深度诊断/KB 入库)完成时,把结果以消息
+ *     形式补送给发起调用的 Agent——不再依赖 Agent 自觉轮询;先到先得去重:Agent 已
+ *     通过 status 工具看到结果的作业不补发(省一次无谓回合)。
+ *  ② HITL 决议补送:审批的等待方已死(运行时被中断/进程重启对账)时,人类的
+ *     批准/拒绝决议与附言仍要以消息形式到达 Agent——人机交互不因链路断裂而丢话。
+ *
+ * 投递语义:
+ *  - 直接落 messages 表(pending):信箱关闭/Agent 未装配也不丢,下次装配按 FIFO 消费;
+ *  - 已装配的 Agent 即时 wakeMailbox(空闲则立即起回合处理回执——"完成即唤醒");
+ *  - 未接线(单测脚手架)时全部 no-op 返回 false,调用方零负担。
+ *
+ * 依赖倒置:本模块只暴露全局 sink;真实实现由 Manager 构造期接线
+ * (见 ManagerState.wirePlatformNoticeSink)——服务层(aml/plugin/hitl)只 import 本模块,
+ * 不反向依赖 manager,无循环装载。
+ */
+import { randomUUID } from 'node:crypto'
+
+/** 异步工具结果回执(claim 键 = tool:jobId;先到先得) */
+export interface PlatformToolResultNotice {
+  kind: 'tool-result'
+  tool: string
+  jobId: string
+  agentId: string
+  /** 缺省按 agentId 反查所属 channel */
+  channelId?: string
+  taskId?: string
+  ok: boolean
+  title: string
+  summary: string
+}
+
+/** HITL 决议/平台事件补送(无 claim 语义,调用方自行保证低频) */
+export interface PlatformHitlNotice {
+  kind: 'hitl-note'
+  agentId: string
+  channelId?: string
+  title: string
+  summary: string
+}
+
+export type PlatformNotice = PlatformToolResultNotice | PlatformHitlNotice
+
+export interface PlatformNoticeSink {
+  /**
+   * 投递通告:原子 claim + 落库 + 唤醒。
+   * 返回 true = 已投递;false = 重复(已投过/已被轮询认领)或不可达(成员已移除/无归属 channel)。
+   * 不可达也视为已消费(成员行不会复活,重试无意义)。
+   */
+  deliver(notice: PlatformNotice): boolean
+  /** 轮询方认领:status 工具把终态结果亲自交给 Agent 时调用,取消后续补送 */
+  claim(tool: string, jobId: string): boolean
+}
+
+const g = globalThis as typeof globalThis & { __platformNoticeSink?: PlatformNoticeSink }
+
+/** Manager 构造期接线(幂等,后到覆盖) */
+export function setPlatformNoticeSink(sink: PlatformNoticeSink): void {
+  g.__platformNoticeSink = sink
+}
+
+export function platformNoticeWired(): boolean {
+  return Boolean(g.__platformNoticeSink)
+}
+
+/** 异步工具结果回执(未接线 → false,作业收口方零负担) */
+export function sendToolResult(input: Omit<PlatformToolResultNotice, 'kind'>): boolean {
+  const sink = g.__platformNoticeSink
+  if (!sink) return false
+  try {
+    return sink.deliver({ kind: 'tool-result', ...input })
+  }
+  catch {
+    return false
+  }
+}
+
+/** 轮询方认领(未接线 → false;两侧都不存在,语义自洽) */
+export function claimToolResult(tool: string, jobId: string): boolean {
+  const sink = g.__platformNoticeSink
+  if (!sink) return false
+  try {
+    return sink.claim(tool, jobId)
+  }
+  catch {
+    return false
+  }
+}
+
+/** HITL 决议/平台事件补送 */
+export function sendHitlNote(input: Omit<PlatformHitlNotice, 'kind'>): boolean {
+  const sink = g.__platformNoticeSink
+  if (!sink) return false
+  try {
+    return sink.deliver({ kind: 'hitl-note', ...input })
+  }
+  catch {
+    return false
+  }
+}
+
+/** 通告键(tool-result 去重主键;hitl-note 无去重需求但保留键空间一致性) */
+export function platformNoticeKey(notice: PlatformNotice): string {
+  return notice.kind === 'tool-result' ? `${notice.tool}:${notice.jobId}` : `hitl:${notice.agentId}:${notice.title}`
+}
+
+/** 消息 id(落库用) */
+export function newPlatformNoticeId(): string {
+  return `pn-${randomUUID()}`
+}

package/server/services/workshop/runtime/scheduler-loop/execute.ts

@@ -11,7 +11,7 @@ import { LoopController, extractTaskMode, isGoalSummaryArtifact } from '../execu
 import { log } from './helpers'
 import { randomUUID } from 'node:crypto'
 import { TERMINAL_TASK_STATES } from '../../types/task'
-import { rootQueueEnabled } from '../../settings'
+import { rootQueueEnabled, workshopSettings } from '../../settings'
 
 export abstract class SchedulerLoopExecute extends SchedulerLoopRules {
   /** 执行单条决策(身份=lead,经 TaskEngine 与 ChannelRuntime) */
@@ -71,6 +71,14 @@ export abstract class SchedulerLoopExecute extends SchedulerLoopRules {
         // lead 自动接取:SUBMITTED → WORKING(§2.2 状态机,dispatch 需父任务处于 WORKING/WAITING)
         if (parent.state === 'SUBMITTED') {
           this.lead.taskEngine.transition(parent.id, 'WORKING', this.lead.agentId)
+          // 排队根任务入场即刷新执行预算:deadline 语义是"执行预算"而非"提交后总时长",
+          // FIFO 等待不应倒扣 —— 否则前面的任务跑超时,后面从未运行的任务会被静默判死。
+          // 能力探测:极简 TaskEngine 替身可能缺方法,缺失时按旧语义跳过。
+          if (!parent.parentId) {
+            const engine = this.lead.taskEngine as { refreshDeadline?: (id: string, iso: string) => unknown }
+            const budgetMs = Math.max(10_000, Number(workshopSettings().root_timeout_ms ?? 900_000))
+            engine.refreshDeadline?.(parent.id, new Date(Date.now() + budgetMs).toISOString())
+          }
         }
         this.lead.taskEngine.dispatch(parent, {
           assigneeId: decision.assigneeId,
@@ -112,7 +120,8 @@ export abstract class SchedulerLoopExecute extends SchedulerLoopRules {
       }
       case 'cancel': {
         const task = this.lead.taskEngine.get(decision.taskId)
-        // 快照后的陈旧取消决策不得再次操作终态任务(包括已超时/已收口任务)。
+        // 陈旧取消决策守卫:终态任务(含 FAILED——重试耗尽子任务)不可取消,与 complete
+        // 的幂等守卫同构。曾因直接调 TaskEngine.cancel 撞终态 409 每 tick 抛异常空转。
         if (!task || TERMINAL_TASK_STATES[task.state] || task.closeReason === 'ROOT_TIMEOUT') break
         this.lead.taskEngine.cancel(decision.taskId, this.lead.agentId, decision.reason ?? 'LEAD_CANCEL')
         // lead 终态同步:经调度器判定取消同样不经 processMessage,重广播队列上下文
@@ -168,7 +177,8 @@ export abstract class SchedulerLoopExecute extends SchedulerLoopRules {
         break
       }
       // 团队成员管理决策(lead 自主扩容/调参/裁撤;经 AgentWorkspace 与工具桥同源路径)。
-      // fire-and-forget:成员落库即刻对下一轮快照可见,dispatch 在后续 tick 自然衔接。
+      // 成员落库即刻对下一轮快照可见,dispatch 在后续 tick 自然衔接。
+      // 失败必须回告 lead:fire-and-forget 曾让 lead 以为扩容成功、向幽灵成员派任务。
       case 'spawn_agent': {
         const ws: AgentWorkspace = this.lead.workspace
         void ws.createTeamMember({
@@ -177,9 +187,10 @@ export abstract class SchedulerLoopExecute extends SchedulerLoopRules {
           config: decision.config,
           templateId: decision.templateId,
           reason: decision.reason,
-        }).catch((err) => {
-          log.error(`[SchedulerLoop:${this.lead.agentId}] spawn_agent 决策执行失败:`, err)
-        })
+        }).then(
+          () => undefined,
+          err => this.memberOpFailed(`spawn_agent`, `新增成员「${decision.name}」失败`, err),
+        )
         break
       }
       case 'update_agent': {
@@ -189,21 +200,42 @@ export abstract class SchedulerLoopExecute extends SchedulerLoopRules {
           config: decision.config,
           enabled: decision.enabled === undefined ? undefined : (decision.enabled ? 1 : 0),
           reason: decision.reason,
-        }).catch((err) => {
-          log.error(`[SchedulerLoop:${this.lead.agentId}] update_agent 决策执行失败:`, err)
-        })
+        }).then(
+          () => undefined,
+          err => this.memberOpFailed(`update_agent`, `调整成员 ${decision.agentId.slice(0, 8)} 失败`, err),
+        )
         break
       }
       case 'remove_agent': {
         const ws: AgentWorkspace = this.lead.workspace
-        void ws.removeTeamMember(decision.agentId, decision.reason).catch((err) => {
-          log.error(`[SchedulerLoop:${this.lead.agentId}] remove_agent 决策执行失败:`, err)
-        })
+        void ws.removeTeamMember(decision.agentId, decision.reason).then(
+          () => undefined,
+          err => this.memberOpFailed(`remove_agent`, `移除成员 ${decision.agentId.slice(0, 8)} 失败`, err),
+        )
         break
       }
     }
   }
 
+  /** 成员管理决策失败回告 lead(信箱消息,下一轮 supervise 前可见;不再静默吞进日志) */
+  private memberOpFailed(op: string, what: string, err: unknown): void {
+    const detail = err instanceof Error ? err.message : String(err)
+    log.error(`[SchedulerLoop:${this.lead.agentId}] ${op} 决策执行失败:`, err)
+    try {
+      this.channelRuntime.route({
+        messageId: randomUUID(),
+        contextId: this.channelRuntime.channelId,
+        role: 'ROLE_AGENT',
+        parts: [{ text: `[成员管理失败] ${what}:${detail}。请勿向该成员派发任务;如仍需要请重试或改用现有成员。` }],
+        metadata: {
+          'x-aw-target-agent': this.lead.agentId,
+          'x-aw-from-agent': this.lead.agentId,
+        },
+      })
+    }
+    catch { /* 回告失败不阻断调度 */ }
+  }
+
   protected wakeAgent(agentId: string): void {
     this.channelRuntime.wakeAgent(agentId)
   }

package/server/services/workshop/runtime/scheduler-loop/rules.ts

@@ -5,6 +5,7 @@
 import { SchedulerLoopSnapshot } from './snapshot'
 import type { SchedulerDecision } from './types'
 import type { SupervisionDecision, SupervisionSnapshot } from '../../agents/agent-interface'
+import { TERMINAL_TASK_STATES } from '../../types/task'
 
 export abstract class SchedulerLoopRules extends SchedulerLoopSnapshot {
   /** 内置规则引擎兜底(harness 无关) */
@@ -19,7 +20,8 @@ export abstract class SchedulerLoopRules extends SchedulerLoopSnapshot {
     // 任务按 createdAt ASC 迭代(list 顺序)= 外部提交 FIFO:先提交先分解先分发。
     for (const task of tasks) {
       // FAILED 且 retryCount<3:优先换人重试;仅剩原 assignee 空闲(如单 worker channel)
-      // → 由原 assignee 重试(reassign 到自己,走 FAILED→ASSIGNED 恢复);无人可用 → cancel(允许终结)
+      // → 由原 assignee 重试(reassign 到自己,走 FAILED→ASSIGNED 恢复);无人可用 → 保留 FAILED
+      // 留给父任务收口规则(直接 cancel FAILED 会撞终态 409——实测曾是每 tick 空转的死代码)。
       if (task.state === 'FAILED') {
         // Roots are Lead-owned orchestration records. A failed root is surfaced to Lead/user;
         // never auto-assign a root to a worker as if it were a child execution.
@@ -36,14 +38,29 @@ export abstract class SchedulerLoopRules extends SchedulerLoopSnapshot {
             if (same && same.agentId === task.assigneeId) {
               decisions.push({ kind: 'reassign', taskId: task.id, toAgentId: same.agentId })
             }
-            else {
-              decisions.push({ kind: 'cancel', taskId: task.id })
-            }
+            // 无人可用:保持 FAILED(子任务终态),由下方父任务收口规则整体坍缩,
+            // 防止 WAITING 父任务永挂(用户可对 FAILED 根任务显式重试)。
           }
         }
-        else {
-          decisions.push({ kind: 'cancel', taskId: task.id })
-        }
+        // retryCount≥3:重试预算耗尽,保持 FAILED,交父任务收口规则(不再空转 cancel)。
+      }
+    }
+
+    // WAITING 父任务收口:全部子任务已终态、无一 COMPLETED(全部重试耗尽/被取消)
+    // → 整树坍缩为 CANCELED。没有这条规则,"子任务 FAILED×3 + 父任务 WAITING"会
+    // 永久挂死(实测:规则引擎对 FAILED 子任务发的 cancel 决策撞 TaskEngine 终态
+    // 409 从未生效,父任务等不到任何终态迁移,调度器每个 tick 重复空转)。
+    // 有 COMPLETED 子任务(部分成果可收)或仍有非终态子任务时不在此收口 ——
+    // 交给 lead 的监督回合判定(接受部分成果/补发/改派)。
+    for (const task of tasks) {
+      if (task.state !== 'WAITING') continue
+      const children = tasks.filter(t => t.parentId === task.id)
+      if (children.length === 0 || children.some(c => !TERMINAL_TASK_STATES[c.state])) continue
+      const anyCompleted = children.some(c => c.state === 'COMPLETED')
+      const allExhausted = children.every(c => c.state === 'CANCELED'
+        || (c.state === 'FAILED' && (c.retryCount ?? 0) >= 3))
+      if (!anyCompleted && allExhausted) {
+        decisions.push({ kind: 'cancel', taskId: task.id, reason: 'CHILD_RETRIES_EXHAUSTED' })
       }
     }
 

package/server/services/workshop/runtime/scheduler-loop/tick.ts

@@ -8,8 +8,11 @@ import { IDLE_TICK_CAP_MS, LEAD_DECISION_RETRY_MS, log } from './helpers'
 import { TERMINAL_TASK_STATES } from '../../types/task'
 import { findModeTask } from '../execution-mode'
 import { isOrdinaryRoot } from '../task-engine/policy'
+import { workshopSettings } from '../../settings'
 
 export abstract class SchedulerLoopTick extends SchedulerLoopState {
+  /** HITL 等待豁免登记:同一根任务只发一次顺延日志(落定后清理) */
+  protected hitlDeferred = new Set<string>()
   protected async runRound(): Promise<void> {
     this.running = true
     try {
@@ -41,12 +44,52 @@ export abstract class SchedulerLoopTick extends SchedulerLoopState {
     this.tick += 1
     const snapshot = this.collectSnapshot()
     // 普通根任务绝对 deadline 优先于 Lead supervise，防止旧决策在超时后继续派发。
+    // 排队根豁免(2026-10-05 实测缺陷修复):deadline 语义是「执行预算」而非「提交后总时长」,
+    // 预算刷新发生在入场(dispatch SUBMITTED→WORKING)时刻 —— 因此**从未入场的排队根**
+    // (SUBMITTED 且非 activeRoot)不应参与过期判定,否则前序根占住执行位时,
+    // 后面从未运行的任务会被静默判死(实测:同一工作包两次入队两次 ROOT_TIMEOUT)。
     const expiredRoots = snapshot.tasks.filter(task =>
       isOrdinaryRoot(task)
       && !TERMINAL_TASK_STATES[task.state]
       && task.deadlineAt
-      && Date.parse(task.deadlineAt) <= Date.now())
+      && Date.parse(task.deadlineAt) <= Date.now()
+      // SUBMITTED = 从未入场(入场即 WORKING),deadline 语义是执行预算而非提交后总时长,
+      // 预算刷新发生在入场时刻 —— 因此一切 SUBMITTED 根都不参与过期判定。
+      // 旧条件只豁免「非队头」的排队根:队头 SUBMITTED 根(=activeRootId 指向者)在
+      // lead 入场饥饿时(2026-10-06 组合大考实测)照样被处决 —— 饿死 15 分钟后被
+      // ROOT_TIMEOUT 收口,与 D1 入场缺陷叠加成"必死"组合。入场兜底见 manager
+      // rescueStaleRoots:两者配合后,SUBMITTED 根要么被兜底唤醒入场,要么被用户显式处理。
+      && task.state !== 'SUBMITTED')
     if (expiredRoots.length > 0) {
+      // HITL 等待豁免(鲁棒性增强):频道内有待批审批(整包方案/单参下发)时,根任务
+      // 执行预算顺延一个 root_timeout,不做 ROOT_TIMEOUT 收口 —— 审批自身有 fail-closed
+      // 超时(security.recipe_dispatch_timeout_ms),人类思考期不应处决整棵任务树。
+      // 豁免仅在「有待批」时生效;审批落定(批准执行/超时关闭)后预算仍耗尽则照常收口。
+      const hitlPending = await (async () => {
+        try {
+          const { getToolApprovals } = await import('../../agents/tool-approvals')
+          return getToolApprovals().listPending().length > 0
+        }
+        catch { return false }
+      })()
+      if (hitlPending) {
+        const budget = new Date(Date.now() + (Number(workshopSettings().root_timeout_ms) || 900_000)).toISOString()
+        for (const root of expiredRoots) {
+          if (!this.hitlDeferred.has(root.id)) {
+            this.hitlDeferred.add(root.id)
+            log.warn(`[SchedulerLoop:${this.lead.agentId}] 根任务 ${root.id.slice(0, 8)} 预算耗尽,但频道有 HITL 待批 —— 执行预算顺延至 ${budget}`)
+          }
+          try {
+            // 能力探测(mirror execute.ts):极简 TaskEngine 替身可能缺 refreshDeadline,缺失时跳过
+            const engine = this.lead.taskEngine as { refreshDeadline?: (id: string, iso: string) => unknown }
+            engine.refreshDeadline?.(root.id, budget)
+          }
+          catch { /* 任务恰好终态:下一 tick 自然收敛 */ }
+        }
+        this.lead.refreshStatus()
+        return
+      }
+      this.hitlDeferred.clear()
       for (const root of expiredRoots) {
         const closed = this.lead.taskEngine.timeoutTree(root.id, this.lead.agentId)
         for (const task of closed) {
@@ -133,9 +176,13 @@ export abstract class SchedulerLoopTick extends SchedulerLoopState {
     }
 
     // Failed/empty triage does not trigger blind dispatch. Retry the Lead after backoff.
+    // activeRootId 只排除「仍活跃」的根:它指向的根已终态(如 ROOT_TIMEOUT)时不得再排除
+    // 其他未规划根 —— 否则中止回合遗留的 SUBMITTED 根会因指纹不变而永无重试,直到新根超时。
+    const activeRoot = snapshot.activeRootId ? snapshot.tasks.find(t => t.id === snapshot.activeRootId) : null
+    const activeRootAlive = Boolean(activeRoot) && !TERMINAL_TASK_STATES[activeRoot!.state]
     const hasUnplannedLeadRoot = snapshot.tasks.some((task) => {
       if (task.parentId || task.assigneeId !== this.lead.agentId) return false
-      if (snapshot.activeRootId && task.id !== snapshot.activeRootId) return false
+      if (snapshot.activeRootId && activeRootAlive && task.id !== snapshot.activeRootId) return false
       if (task.state !== 'SUBMITTED' && task.state !== 'WORKING') return false
       return !snapshot.tasks.some(child => child.parentId === task.id)
     })

package/server/services/workshop/runtime/task-engine/helpers.ts

@@ -18,7 +18,9 @@ export const log = createLogger('workshop.task-engine')
  *  收口规则只认 WAITING/WORKING,三面都不接) */
 export const TRANSITIONS: Record<TaskState, TaskState[]> = {
   SUBMITTED: ['WORKING', 'ASSIGNED', 'COMPLETED', 'CANCELED'],
-  ASSIGNED: ['WORKING', 'CANCELED'],
+  // ASSIGNED → COMPLETED:mock/rpc worker 无运行时消费 assign(任务永远停在 ASSIGNED),
+  // 交付即视同接取 —— 与 SUBMITTED/WAITING → COMPLETED 的 mock 闭环例外同一口径。
+  ASSIGNED: ['WORKING', 'COMPLETED', 'CANCELED'],
   WORKING: ['WAITING', 'COMPLETED', 'FAILED', 'CANCELED'],
   WAITING: ['WORKING', 'COMPLETED', 'CANCELED'],
   FAILED: ['ASSIGNED', 'CANCELED'],

package/server/services/workshop/runtime/task-engine/lifecycle.ts

@@ -6,6 +6,7 @@ import { TaskEngineTransition } from './transition'
 import type { A2AArtifact } from '../../types/a2a'
 import type { WorkspaceTask } from '../../types/task'
 import { AppError } from '../../../../utils/errors'
+import { workshopSettings } from '../../settings'
 import { extractTaskMode, isGoalSummaryArtifact, synthesizeGoalSummary } from '../execution-mode'
 import { rowToTask } from './helpers'
 import type { ExecutionFence } from './lease'
@@ -109,6 +110,16 @@ export abstract class TaskEngineLifecycle extends TaskEngineTransition {
       retryCount: isRetry ? task.retryCount + 1 : task.retryCount,
     })
     if (!updated) throw new AppError(404, 'NOT_FOUND', `任务不存在: ${taskId}`)
+    // 重试/改派即重置执行预算(2026-10-05 实测缺陷修复):deadline 若保留旧值
+    // (FAILED 根的预算早已耗尽),重试后下一 tick 立即再进 expiredRoots —— 秒死循环。
+    // deadline 语义 = 执行预算:重新指派 = 新一轮执行,预算从现在起算。
+    if (isRetry) {
+      const budget = new Date(Date.now() + (Number(workshopSettings().root_timeout_ms) || 900_000)).toISOString()
+      try {
+        this.repos.tasks.update(taskId, { deadlineAt: budget })
+      }
+      catch { /* 极简替身缺 update 时忽略:最坏回到旧行为 */ }
+    }
     if (isRetry) this.transition(taskId, 'ASSIGNED', previousAssigneeId)
     // 旧 assignee 队列中的 assign 投递已过期:作废后仅向新 assignee 投递
     this.repos.messages.consumePendingByTask(taskId)