agentworkshop 0.8.6 → 0.8.8

package/server/services/workshop/runtime/embedding-provider.ts

@@ -1,83 +1,100 @@
-/**
- * Embedding provider — OpenAI 兼容 /embeddings 端点(配置驱动,原生 fetch 零 SDK)。
- * 未配置(memory.embed_base_url/embed_model 均空)→ 返回 null(向量分支整体关闭,记忆系统纯 FTS 降级)。
- * 覆盖链:config.yml < runtime-settings < env(AW_MEMORY_EMBED_*);原生 fetch 零 SDK。
- * 熔断:连续 3 次失败禁用 10 分钟(避免每个任务都白等超时)。
- * 维度:首次成功 embed 的返回长度(不信任配置,以实测为准)。
- */
-import { memorySettings } from '../settings'
-
-export interface EmbeddingProvider {
-  embed(texts: string[]): Promise<Float32Array[]>
-  /** 已知维度(首次成功 embed 前 null) */
-  dims(): number | null
-}
-
-const FAIL_THRESHOLD = 3
-const COOLDOWN_MS = 10 * 60_000
-const REQUEST_TIMEOUT_MS = 10_000
-
-export function createEnvEmbeddingProvider(): EmbeddingProvider | null {
-  const memoryCfg = memorySettings()
-  const baseUrl = memoryCfg.embed_base_url || undefined
-  const model = memoryCfg.embed_model || undefined
-  if (!baseUrl || !model) return null
-  const apiKey = memoryCfg.embed_api_key ?? ''
-  let dims: number | null = null
-  let fails = 0
-  let disabledUntil = 0
-
-  return {
-    dims: () => dims,
-    async embed(texts: string[]): Promise<Float32Array[]> {
-      if (Date.now() < disabledUntil) throw new Error('embedding provider 冷却中')
-      let res: Response
-      try {
-        res = await fetch(`${baseUrl.replace(/\/$/, '')}/embeddings`, {
-          method: 'POST',
-          headers: { 'content-type': 'application/json', ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}) },
-          body: JSON.stringify({ input: texts, model }),
-          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-        })
-      }
-      catch (err) {
-        // 网络层失败(拒绝连接/超时)同样计入熔断——超时是最常见失败形态
-        if (++fails >= FAIL_THRESHOLD) {
-          disabledUntil = Date.now() + COOLDOWN_MS
-          fails = 0
-        }
-        throw err
-      }
-      if (!res.ok) {
-        if (++fails >= FAIL_THRESHOLD) {
-          disabledUntil = Date.now() + COOLDOWN_MS
-          fails = 0
-        }
-        throw new Error(`embedding HTTP ${res.status}`)
-      }
-      const json = await res.json() as { data: Array<{ embedding: number[] }> }
-      dims = json.data[0]?.embedding.length ?? dims
-      fails = 0
-      return json.data.map(d => Float32Array.from(d.embedding))
-    },
-  }
-}
-
-/** 测试用确定性词袋 hash provider:相同词集 → 相近向量(零网络)。 */
-export function createHashEmbeddingProvider(dims: number): EmbeddingProvider {
-  return {
-    dims: () => dims,
-    async embed(texts: string[]): Promise<Float32Array[]> {
-      return texts.map((t) => {
-        const v = new Float32Array(dims)
-        for (const w of t.toLowerCase().split(/\s+/).filter(Boolean)) {
-          let h = 2166136261
-          for (let i = 0; i < w.length; i++) h = Math.imul(h ^ w.charCodeAt(i), 16777619)
-          v[Math.abs(h) % dims] = (v[Math.abs(h) % dims] ?? 0) + 1
-        }
-        const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1
-        return v.map(x => x / norm) as Float32Array
-      })
-    },
-  }
-}
+/**
+ * Embedding provider — OpenAI 兼容 /embeddings 端点(配置驱动,原生 fetch 零 SDK)。
+ * 未配置(memory.embed_base_url/embed_model 均空)→ 返回 null(向量分支整体关闭,记忆系统纯 FTS 降级)。
+ * 覆盖链:config.yml < runtime-settings < env(AW_MEMORY_EMBED_*);原生 fetch 零 SDK。
+ * 熔断:连续 3 次失败禁用 10 分钟(避免每个任务都白等超时)。
+ * 维度:首次成功 embed 的返回长度(不信任配置,以实测为准)。
+ */
+import { memorySettings } from '../settings'
+import { allowPrivateOutbound, assertSafeHttpUrl } from '../net/ssrf'
+
+export interface EmbeddingProvider {
+  embed(texts: string[]): Promise<Float32Array[]>
+  /** 已知维度(首次成功 embed 前 null) */
+  dims(): number | null
+}
+
+const FAIL_THRESHOLD = 3
+const COOLDOWN_MS = 10 * 60_000
+const REQUEST_TIMEOUT_MS = 10_000
+
+export function createEnvEmbeddingProvider(): EmbeddingProvider | null {
+  const memoryCfg = memorySettings()
+  const baseUrl = memoryCfg.embed_base_url || undefined
+  const model = memoryCfg.embed_model || undefined
+  if (!baseUrl || !model) return null
+  const apiKey = memoryCfg.embed_api_key ?? ''
+  let dims: number | null = null
+  let fails = 0
+  let disabledUntil = 0
+  // baseUrl 来自运行时设置(admin 可改):必须过 SSRF 护栏,否则可被指向内网/元数据服务。
+  // 每实例校验一次(URL 不变),失败即永久熔断并记原因。
+  let urlChecked = false
+  let urlError: string | null = null
+
+  return {
+    dims: () => dims,
+    async embed(texts: string[]): Promise<Float32Array[]> {
+      if (Date.now() < disabledUntil) throw new Error('embedding provider 冷却中')
+      if (!urlChecked) {
+        urlChecked = true
+        try {
+          await assertSafeHttpUrl(baseUrl, { label: 'embedding 服务', allowPrivateHost: allowPrivateOutbound() ? 'true' : 'false' })
+        }
+        catch (err) {
+          urlError = err instanceof Error ? err.message : String(err)
+          disabledUntil = Number.POSITIVE_INFINITY
+          // cause 保留原始错误栈/类型,便于上游诊断 SSRF 拒因
+          throw new Error(`embedding 服务地址被 SSRF 防护拒绝:${urlError}`, { cause: err })
+        }
+      }
+      let res: Response
+      try {
+        res = await fetch(`${baseUrl.replace(/\/$/, '')}/embeddings`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}) },
+          body: JSON.stringify({ input: texts, model }),
+          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        })
+      }
+      catch (err) {
+        // 网络层失败(拒绝连接/超时)同样计入熔断——超时是最常见失败形态
+        if (++fails >= FAIL_THRESHOLD) {
+          disabledUntil = Date.now() + COOLDOWN_MS
+          fails = 0
+        }
+        throw err
+      }
+      if (!res.ok) {
+        if (++fails >= FAIL_THRESHOLD) {
+          disabledUntil = Date.now() + COOLDOWN_MS
+          fails = 0
+        }
+        throw new Error(`embedding HTTP ${res.status}`)
+      }
+      const json = await res.json() as { data: Array<{ embedding: number[] }> }
+      dims = json.data[0]?.embedding.length ?? dims
+      fails = 0
+      return json.data.map(d => Float32Array.from(d.embedding))
+    },
+  }
+}
+
+/** 测试用确定性词袋 hash provider:相同词集 → 相近向量(零网络)。 */
+export function createHashEmbeddingProvider(dims: number): EmbeddingProvider {
+  return {
+    dims: () => dims,
+    async embed(texts: string[]): Promise<Float32Array[]> {
+      return texts.map((t) => {
+        const v = new Float32Array(dims)
+        for (const w of t.toLowerCase().split(/\s+/).filter(Boolean)) {
+          let h = 2166136261
+          for (let i = 0; i < w.length; i++) h = Math.imul(h ^ w.charCodeAt(i), 16777619)
+          v[Math.abs(h) % dims] = (v[Math.abs(h) % dims] ?? 0) + 1
+        }
+        const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1
+        return v.map(x => x / norm) as Float32Array
+      })
+    },
+  }
+}

package/server/services/workshop/runtime/execution-mode.ts

@@ -29,6 +29,8 @@ export interface ModeConfig {
   stages?: PipelineStage[]
   /** goal: 满意度判断提示(注入 lead prompt) */
   goalCriteria?: string
+  /** goal: 完成策略(缺省 default=必须有真实交付物;no-deliverable=显式声明无交付目标) */
+  completionPolicy?: 'default' | 'no-deliverable'
 }
 
 /** pipeline 阶段定义 */
@@ -76,6 +78,9 @@ function parseModeConfig(desc: string, mode: ExecutionMode): ModeConfig {
     // goalCriteria 从 description 中 [criteria:...] 提取
     const criteriaMatch = desc.match(/\[criteria:([^\]]+)\]/)
     config.goalCriteria = criteriaMatch?.[1]?.trim()
+    // 完成策略:[policy:no-deliverable] 显式声明无交付目标(缺省 default=必须有真实证据)
+    const policyMatch = desc.match(/\[policy:(no-deliverable|default)\]/)
+    config.completionPolicy = (policyMatch?.[1] as ModeConfig['completionPolicy']) ?? 'default'
   }
   if (mode === 'pipeline') {
     // 阶段名从 [stages:name1->name2] 提取(与 encodeTaskMode 编码格式对称)
@@ -109,6 +114,9 @@ export function encodeTaskMode(mode: ExecutionMode, config: ModeConfig, descript
   if (mode === 'goal' && config.goalCriteria) {
     parts.push(`[criteria:${config.goalCriteria}]`)
   }
+  if (mode === 'goal' && config.completionPolicy === 'no-deliverable') {
+    parts.push('[policy:no-deliverable]')
+  }
   if (mode === 'pipeline' && config.stages) {
     parts.push(`[stages:${config.stages.map(s => s.name).join('->')}]`)
   }

package/server/services/workshop/runtime/manager/admin-channel.ts

@@ -261,18 +261,25 @@ export abstract class ManagerAdminChannel extends ManagerNotifications {
   protected async unloadChannelAgents(channelId: string): Promise<void> {
     const cr = this.channels.get(channelId)
     if (cr) {
-      const scheduler = cr.scheduler
-      if (scheduler) await scheduler.stopAndWait()
-      cr.scheduler = null
-      const agents = [...cr.getAgents()]
-      for (const agent of agents) {
-        await agent.stop()
-        cr.detachAgent(agent.agentId)
-        this.agentIndex.delete(runtimeKey(channelId, agent.agentId))
+      let releaseSchedulerStarts: (() => void) | null = null
+      let unloaded = false
+      try {
+        releaseSchedulerStarts = await cr.stopSchedulersAndWait()
+        const agents = [...cr.getAgents()]
+        for (const agent of agents) {
+          await agent.stop()
+          cr.detachAgent(agent.agentId)
+          this.agentIndex.delete(runtimeKey(channelId, agent.agentId))
+        }
+        if (cr.getAgents().length === 0) {
+          this.channels.delete(channelId)
+          this.buses.delete(channelId)
+        }
+        unloaded = true
       }
-      if (cr.getAgents().length === 0) {
-        this.channels.delete(channelId)
-        this.buses.delete(channelId)
+      finally {
+        // Reopening is safe only after every old runtime has been detached.
+        if (unloaded && this.channels.get(channelId) === cr) releaseSchedulerStarts?.()
       }
     }
   }
@@ -296,9 +303,7 @@ export abstract class ManagerAdminChannel extends ManagerNotifications {
   async removeChannel(channelId: string): Promise<void> {
     const cr = this.channels.get(channelId)
     if (cr) {
-      const scheduler = cr.scheduler
-      if (scheduler) await scheduler.stopAndWait()
-      cr.scheduler = null
+      await cr.stopSchedulersAndWait()
       for (const agent of [...cr.getAgents()]) {
         await agent.stop()
         this.agentIndex.delete(runtimeKey(channelId, agent.agentId))

package/server/services/workshop/runtime/manager/chat.ts

@@ -12,12 +12,14 @@ import type { WorkshopPermissionScope } from '../../../../../shared/workshop-pro
 import { AppError } from '../../../../utils/errors'
 import { WORKSHOP_PERMISSION_SCOPE_HEADER, parseWorkshopPermissionScope } from '../../../../../shared/workshop-protocol'
 import { agentMentions, resolveMentions, userMentions } from '../chat-mention'
-import { buildMessage, resolveOwnerName } from './helpers'
+import { buildMessage, log, resolveOwnerName } from './helpers'
 import { parseJson } from '../../db/database'
 import { projectChatMessage, projectChatSnapshot } from '../chat-projection'
 import { withTransaction } from '../../db/transaction'
 
 export abstract class ManagerChat extends ManagerAccess {
+  /** chat 投递重试上限(超过转 failed 死信;与 memory outbox 对齐) */
+  protected static readonly CHAT_DELIVERY_MAX_ATTEMPTS = 5
   /**
    * SQLite 事务包裹(可重入;失败一律回滚)。
    *
@@ -339,6 +341,10 @@ export abstract class ManagerChat extends ManagerAccess {
     if (current && current.status !== 'pending') {
       return { deliveryId, agentId: targetAgentId, status: current.status }
     }
+    // 确定性 mailbox 消息 id(=投递台账 id 派生):同一条 delivery 无论正常投递还是
+    // 崩溃重投,messages 表行 id 恒同 —— PK 冲突天然去重,第二窗口(已落库/台账未更)
+    // 的重投不会产生第二条 mailbox 消息(整改计划阶段2)
+    const mailboxMessageId = `dlv-${deliveryId}`
     try {
       const message = buildMessage(channelId, 'ROLE_USER', [{ text: this.chatPromptText(ctx.requesterName, text) }], {
         'x-aw-target-agent': targetAgentId,
@@ -380,7 +386,61 @@ export abstract class ManagerChat extends ManagerAccess {
       return finish('delivered', { mailboxMessageId: message.messageId })
     }
     catch (err) {
-      return finish('failed', { error: err instanceof Error ? err.message : String(err) })
+      const msgText = err instanceof Error ? err.message : String(err)
+      // 崩溃重投幂等:mailbox 行已存在(上一进程已 route 但未及 finish)→ 视为已投递,
+      // 回填既有确定性 id,不产生第二条 mailbox 消息(阶段2)
+      if (/UNIQUE|PRIMARY KEY|already exists/i.test(msgText)) {
+        return finish('delivered', { mailboxMessageId })
+      }
+      return finish('failed', { error: msgText })
+    }
+  }
+
+  /**
+   * chat 投递崩溃恢复补偿器(整改计划 2026-10-30 阶段2):
+   * 扫描 pending 且 mailbox 未落库的投递(丢失窗口=事务已提交、route 未完成),
+   * 退避重投;超限转 failed 死信(可见、可审计)。mailbox 已落库的 pending(第二窗口)
+   * 经确定性消息 id 去重,重投不会产生第二条 mailbox 消息。
+   * 由 ManagerState 的 15s 定时器与 restore() 驱动;体内只做同步 DB 写(§ chat.ts:28 事务纪律)。
+   */
+  protected recoverPendingChatDeliveries(): void {
+    const now = new Date().toISOString()
+    const rows = this.chatMessageRepo.listRetryableDeliveries(now, 50)
+    for (const row of rows) {
+      if (row.attempts >= ManagerChat.CHAT_DELIVERY_MAX_ATTEMPTS) {
+        if (this.chatMessageRepo.markDeliveryDead(row.id, `投递重试 ${row.attempts} 次仍未落 mailbox,转死信(可人工排查后重试)`)) {
+          this.publishChatDelivery(row.channelId, row.id)
+        }
+        continue
+      }
+      const source = this.chatMessageRepo.findById(row.chatMessageId)
+      if (!source || source.channelId !== row.channelId) {
+        if (this.chatMessageRepo.markDeliveryDead(row.id, '源消息缺失或跨频道,无法重投'))
+          this.publishChatDelivery(row.channelId, row.id)
+        continue
+      }
+      // claim + 退避排程先行(单进程同步写;崩溃后下次扫描按 next_retry_at 续跑)
+      const backoffMs = Math.min(15_000 * 2 ** row.attempts, 300_000)
+      this.chatMessageRepo.bumpDeliveryRetry(row.id, new Date(Date.now() + backoffMs).toISOString())
+      const requesterUserId = source.requesterUserId ?? (source.senderType === 'user' ? source.senderId : '')
+      const requesterName = source.senderName || this.displayNameOf(requesterUserId)
+      let mentions: ChatMention[]
+      try {
+        mentions = JSON.parse(source.mentionsJson ?? '[]') as ChatMention[]
+      }
+      catch {
+        mentions = []
+      }
+      try {
+        this.deliverChatToAgent(row.channelId, source.id, row.id, row.targetAgentId, source.text, {
+          requesterUserId,
+          requesterName,
+          mentions,
+        })
+      }
+      catch (err) {
+        log.warn(`[chat] 投递恢复失败 delivery=${row.id.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`)
+      }
     }
   }
 }

package/server/services/workshop/runtime/manager/contracts.ts

@@ -88,6 +88,13 @@ export abstract class ManagerContracts {
     callerAgentId: string,
     input: { taskId: string, artifacts?: A2AArtifact[] },
   ): Promise<WorkspaceTask>
+  abstract supersedeTask(
+    channelId: string,
+    callerAgentId: string,
+    input: { taskId: string, replacementTaskId: string, reason?: string },
+  ): Promise<WorkspaceTask>
+  /** chat 投递崩溃恢复补偿器(阶段2;实现在 chat 层,由 state 定时器与 restore 驱动) */
+  protected abstract recoverPendingChatDeliveries(): void
   abstract createTeamMember(
     channelId: string,
     callerAgentId: string,

package/server/services/workshop/runtime/manager/helpers.ts

@@ -48,6 +48,8 @@ export function rowToTask(row: TaskRow): WorkspaceTask {
     artifacts: parseJson<A2AArtifact[]>(row.artifactsJson, []),
     history: parseJson<A2AMessage[]>(row.historyJson, []),
     routeReason: row.routeReason || undefined,
+    // 显式替代关系(整改计划阶段1):host 工具面 precheck 依赖此字段豁免已处置分支
+    supersededByTaskId: row.supersededByTaskId || undefined,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   }
@@ -69,14 +71,15 @@ export function rowToChannelMail(row: MessageRow): ChannelMail {
   }
 }
 
-/** 构造 A2AMessage(统一入口) */
+/** 构造 A2AMessage(统一入口);id 显式传入时用之(崩溃重投按确定性 id 去重,阶段2) */
 export function buildMessage(
   channelId: string,
   role: 'ROLE_USER' | 'ROLE_AGENT',
   parts: Part[],
   metadata: Record<string, unknown>,
+  id?: string,
 ): A2AMessage {
-  return { messageId: randomUUID(), contextId: channelId, role, parts, metadata }
+  return { messageId: id ?? randomUUID(), contextId: channelId, role, parts, metadata }
 }
 
 /** 运行时实例复合键(channel, 实例) */

package/server/services/workshop/runtime/manager/runtime-observe.ts

@@ -289,9 +289,7 @@ export abstract class ManagerRuntimeObserve extends ManagerRuntimeWiring {
     }
     this.scheduleRuntime?.stop()
     this.scheduleRuntime = null
-    const schedulers = [...this.channels.values()].map(cr => cr.scheduler).filter((s): s is NonNullable<typeof s> => !!s)
-    await Promise.all(schedulers.map(s => s.stopAndWait()))
-    for (const cr of this.channels.values()) cr.scheduler = null
+    await Promise.all([...this.channels.values()].map(cr => cr.stopSchedulersAndWait()))
     await Promise.all([...this.agentIndex.values()].map(a => a.stop()))
     this.agentIndex.clear()
     this.channels.clear()

package/server/services/workshop/runtime/manager/runtime-wiring.ts

@@ -139,7 +139,7 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
   protected ensureAgentRuntime(channelId: string, agentId: string): AgentRuntime | undefined {
     const key = runtimeKey(channelId, agentId)
     // 停机窗口墓碑:既不返回半关闭的旧运行时,也不重建新运行时(否则消息进闭箱)
-    if (this.stoppingAgents.has(key)) return undefined
+    if (this.stoppingAgents.has(key) || this.channels.get(channelId)?.schedulerStoppingInProgress) return undefined
     const existing = this.agentIndex.get(key)
     if (existing) return existing
     const m = this.deps.repos.channelAgents.findByChannelAgent(channelId, agentId)
@@ -156,6 +156,7 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
     const channel = this.deps.repos.channels.findById(channelId)
     if (!channel || channel.enabled !== 1 || !channel.leadAgentId) return
     const cr = this.ensureChannelRuntime(channelId)
+    if (cr.schedulerStoppingInProgress) return
     if (cr.scheduler) return
     const lead = this.ensureAgentRuntime(channelId, channel.leadAgentId)
     if (!lead) return
@@ -185,6 +186,7 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
     const channel = this.deps.repos.channels.findById(channelId)
     if (!channel || channel.enabled !== 1 || !channel.leadAgentId) return
     const cr = this.ensureChannelRuntime(channelId)
+    if (cr.schedulerStoppingInProgress) return
     if (cr.scheduler) return
     const lead = this.runtimeOf(channelId, channel.leadAgentId)
     if (!lead || lead.role !== 'lead') return
@@ -209,7 +211,7 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
     // shutdown 之后不得再挂新调度器:shutdown 会停掉全部循环并置空 cr.scheduler,
     // 但此窗口内仍可能有在途的懒装配(channelRuntime loader / 定时任务 / 在飞投递)
     // 经 wireMember → reviveScheduler 重新挂载。
-    if (this.shutdownStarted) return
+    if (this.shutdownStarted || cr.schedulerStoppingInProgress) return
     if (cr.scheduler) return
     const loop = new SchedulerLoop(cr, lead, {
       // 停滞窗口默认取 workshop.stall_ms(默认 5 分钟,可经设置调整):
@@ -254,15 +256,15 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
     const cr = this.channels.get(channelId)
     cr?.detachAgent(agentId)
     this.clearInvocationScope(agentId)
+    let releaseSchedulerStarts: (() => void) | null = null
     try {
-      const scheduler = runtime.role === 'lead' ? cr?.scheduler : null
-      if (scheduler) {
-        await scheduler.stopAndWait()
-        if (cr) cr.scheduler = null
+      if (runtime.role === 'lead' && cr) {
+        releaseSchedulerStarts = await cr.stopSchedulersAndWait()
       }
       await runtime.stop()
     }
     finally {
+      releaseSchedulerStarts?.()
       // 停机完成即允许惰性复活(新消息触发 wireMember 重建)
       this.stoppingAgents.delete(key)
     }
@@ -415,6 +417,16 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
       // 正规 assign 消息(与人类直发 worker 同构):FIFO 准入已满足(无活跃根+最老 seq),
       // assign 语义让 lead 消息路径自动 SUBMITTED→WORKING(补 RUNNING 中间态可见性),
       // 回合载荷=任务简报,走消息消费循环的稳健入场路径。
+      // 2026-10-30 修复(救援竞争):上面 unloadAgent 是秒级 await,窗口内旧运行时的在途
+      // 消费/监督决策可能已把该根 SUBMITTED→WORKING(甚至继续派发子任务)。投递前必须
+      // 复读:非 SUBMITTED 说明入场已发生,再投 assign 会复活出同任务的第二回合并发执行
+      // (双份 history/artifact 交错、重复派发子任务;lease 栅栏对无栅栏字段的救援 assign
+      // 不设防)。复读与 route 之间无 await,单进程下原子。
+      const freshHead = this.deps.repos.tasks.findById(head.id)
+      if (!freshHead || String(freshHead.state) !== 'SUBMITTED') {
+        log.warn(`[AgentChannelManager] D1 兜底:根任务 ${head.id.slice(0, 8)} 在重组窗口内已入场(state=${freshHead ? String(freshHead.state) : '缺失'}),跳过重复投递`)
+        continue
+      }
       const brief = [head.title, head.description ?? ''].filter(Boolean).join('\n')
       const rescueMessage = buildMessage(
         channel.id,

package/server/services/workshop/runtime/manager/schedules.ts

@@ -22,6 +22,13 @@ export abstract class ManagerSchedules extends ManagerHostTools {
     catch (err) {
       log.error('[restore] outbox 补偿失败(不阻断恢复):', err)
     }
+    // 2026-10-30 阶段2:重启即恢复 chat 投递(崩溃窗口滞留的 pending 立即重投,不等 15s 周期)
+    try {
+      this.recoverPendingChatDeliveries()
+    }
+    catch (err) {
+      log.error('[restore] chat 投递恢复失败(不阻断恢复):', err)
+    }
     const nonTerminal = this.deps.repos.tasks.listNonTerminal()
     const activeChannelIds = new Set(nonTerminal.map(t => t.channelId))
     for (const channelId of activeChannelIds) {

package/server/services/workshop/runtime/manager/state.ts

@@ -72,6 +72,8 @@ const MEMORY_OUTBOX_MAX_ATTEMPTS = 5
 const TEAM_MEMORY_CHECKPOINT_CAP = 500
 /** §7.3 outbox 补偿扫描周期(独立于记忆维护的 6h 周期) */
 const OUTBOX_COMPENSATION_MS = 30_000
+/** chat 投递崩溃恢复扫描周期(整改计划 2026-10-30 阶段2) */
+const CHAT_DELIVERY_RECOVERY_MS = 15_000
 
 export abstract class ManagerState extends ManagerContracts {
   protected channels = new Map<string, ChannelRuntime>()
@@ -89,6 +91,7 @@ export abstract class ManagerState extends ManagerContracts {
   protected memoryTimer: NodeJS.Timeout | null = null
   /** §7.3 outbox 独立补偿定时器(短周期重试;与记忆维护 6h 周期解耦) */
   protected outboxTimer: NodeJS.Timeout | null = null
+  protected chatDeliveryTimer: NodeJS.Timeout | null = null
   /** 全 manager 共享的 env 向量 provider(未配置 → null 纯 FTS;熔断/维度全体实例共享) */
   protected readonly memoryEmbedder = createEnvEmbeddingProvider()
   /** 反思游标:每 agent 上次聚合的当月任务数(月度幂等增量判定) */
@@ -108,7 +111,7 @@ export abstract class ManagerState extends ManagerContracts {
     const b = toolActivityAt(agentId) ?? 0
     const at = Math.max(a, b)
     return at > 0 ? at : null
-  }
+  }
 
   /**
    * 每个 Agent 当前正在服务的**人类发起者作用域**(§13.3)。
@@ -137,7 +140,7 @@ export abstract class ManagerState extends ManagerContracts {
    */
   protected clearInvocationScope(agentId: string, invocationId?: string | null): void {
     settleInvocationScope(this.activeInvocationScopes, agentId, invocationId)
-  }
+  }
 
   /** v16 定时任务执行器(timer 唯一持有者;startScheduleRuntime 装配,shutdown 停止) */
   protected scheduleRuntime: ScheduleRuntime | null = null
@@ -202,6 +205,17 @@ export abstract class ManagerState extends ManagerContracts {
       }
     }, OUTBOX_COMPENSATION_MS)
     this.outboxTimer.unref?.()
+    // 2026-10-30 阶段2:chat 投递崩溃恢复补偿器 —— pending 且 mailbox 未落库的投递退避重投
+    // (窗口=事务已提交、route 未完成;mailbox 已落库的 pending 由确定性消息 id 去重,不会重复投递)
+    this.chatDeliveryTimer = setInterval(() => {
+      try {
+        this.recoverPendingChatDeliveries()
+      }
+      catch (err) {
+        log.error('[chat] 投递恢复 worker 异常', err)
+      }
+    }, CHAT_DELIVERY_RECOVERY_MS)
+    this.chatDeliveryTimer.unref?.()
   }
 
   /**

package/server/services/workshop/runtime/manager/tasks.ts

@@ -276,8 +276,17 @@ export abstract class ManagerTasks extends ManagerChannelTemplates {
     const trimmedReason = reason.trim()
     if (!trimmedReason) throw new AppError(400, 'BAD_REQUEST', '拒绝必须说明原因(reason)')
 
+    // 2026-10-30 修复(诚实回执对齐):终态任务此前「跳过迁移但照发拒绝回执+照报成功」
+    // —— lead 据「请改派」回执会对已收口任务重复派发(双倍执行/双倍产线操作)。
+    // completeTask/cancelTask 对终态都显式 409,唯独 refuse 沿用旧静默路径;
+    // 迟到回合的拒绝必须显式失败,不能污染调度。
+    if (TERMINAL_TASK_STATES[task.state]) {
+      throw new AppError(409, 'TASK_TERMINAL',
+        `任务 ${taskId.slice(0, 8)} 已终态(${task.state}),拒绝无效 —— 该任务已收口,这不是你的错误,请勿再处理,继续处理队列下一项`)
+    }
+
     let current = task
-    if (!TERMINAL_TASK_STATES[current.state]) {
+    {
       // 状态机需经 WORKING 到 FAILED(SUBMITTED/ASSIGNED 直达 FAILED 非法)
       if (current.state === 'SUBMITTED' || current.state === 'ASSIGNED') {
         current = engine.transition(taskId, 'WORKING', refuserId)
@@ -380,6 +389,30 @@ export abstract class ManagerTasks extends ManagerChannelTemplates {
     return completed
   }
 
+  /** 显式替代(整改计划阶段1/F1):lead 把 FAILED/CANCELED 分支标记为被 replacement 覆盖。
+   *  权限与 completeTask 同口径:仅父任务 assignee(lead)可处置分支收口。 */
+  async supersedeTask(
+    channelId: string,
+    callerAgentId: string,
+    input: { taskId: string, replacementTaskId: string, reason?: string },
+  ): Promise<WorkspaceTask> {
+    const task = this.requireTaskInScope(channelId, callerAgentId, input.taskId)
+    if (!task.parentId) {
+      throw new AppError(400, 'INVALID_STATE', '仅子任务分支可被替代')
+    }
+    const parent = this.requireTaskInScope(channelId, callerAgentId, task.parentId)
+    if (parent.assigneeId !== callerAgentId) {
+      throw new AppError(403, 'SCOPE_VIOLATION', '仅父任务 assignee(lead)可标记替代')
+    }
+    const replacement = this.requireTaskInScope(channelId, callerAgentId, input.replacementTaskId)
+    if (replacement.channelId !== channelId) {
+      throw new AppError(403, 'SCOPE_VIOLATION', '替代任务不在本频道作用域内')
+    }
+    const result = this.getTaskEngine().supersede(input.taskId, input.replacementTaskId, callerAgentId, input.reason)
+    this.wakeAgent(channelId, parent.assigneeId)
+    return result
+  }
+
   async cancelTask(
     channelId: string,
     callerAgentId: string,

package/server/services/workshop/runtime/manager/workspace.ts

@@ -21,6 +21,7 @@ export abstract class ManagerWorkspace extends ManagerRuntimeObserve {
       getTask: taskId => this.getTask(channelId, agent.id, taskId),
       reportTask: input => this.reportTask(channelId, agent.id, input),
       completeTask: (taskId, artifacts) => this.completeTask(channelId, agent.id, { taskId, artifacts }),
+      supersedeTask: (taskId, replacementTaskId, reason) => this.supersedeTask(channelId, agent.id, { taskId, replacementTaskId, reason }),
       cancelTask: taskId => this.cancelTask(channelId, agent.id, { taskId }),
       myQueue: () => this.myQueue(channelId, agent.id),
       queueOverview: () => this.queueOverview(channelId, agent.id),

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

@@ -135,7 +135,23 @@ export abstract class SchedulerLoopRules extends SchedulerLoopSnapshot {
         // progress=90、产物齐全,却因没走收口动作被整单取消;换成真实 harness lead 时
         // 由 lead 的监督回合兜住,所以只在 mock/规则引擎这条路径上暴露)。
         // 现在按"有没有真干过活"分流:干过 → 收口(成果保留);没干过 → 仍然取消(防永挂)。
-        const didWork = (task.artifacts ?? []).some(a => a.name !== 'input'
+        // 2026-10-30 修复:快照 artifacts 是监督投影(listForSupervision),子任务分支只含
+        // COMPLETED(selectActiveSupervisionArtifacts 硬条件)→ WORKING 子任务恒
+        // artifacts=[],didWork 恒 false → 分流对子任务是死代码,有交付物仍被整单取消;
+        // 而 WORKING 根任务 artifacts 恒可见 → 停滞时被规则引擎自动 complete,违反
+        // "恢复引擎绝不自动验收父任务"不变量(本文件末尾注释)。改为:判定点现读该任务
+        // 全行 artifacts(单行,绕开投影裁剪);根任务一律不做破坏性/越权收口,只重复上报。
+        if (!task.parentId) {
+          this.lastProgress.set(task.id, { progress: task.progress, at: now })
+          decisions.push({
+            kind: 'notify',
+            toAgentId: task.assigneeId,
+            parts: [{ text: `根任务「${task.title}」停滞且进度长期无变化 —— 请立即检查并处置(验收收口/继续推进/说明阻塞);恢复引擎不会代你验收或取消根任务` }],
+          })
+          continue
+        }
+        const fresh = (this.lead.taskEngine as { get?: (id: string) => typeof task | undefined }).get?.(task.id)
+        const didWork = ((fresh ?? task).artifacts ?? []).some(a => a.name !== 'input'
           && (a.parts ?? []).some(p => 'text' in p ? p.text.trim().length > 0 : true))
         decisions.push(didWork ? { kind: 'complete', taskId: task.id } : { kind: 'cancel', taskId: task.id })
       }