agentworkshop 0.8.6 → 0.8.8

package/server/services/workshop/ops/error-ledger.ts

@@ -0,0 +1,209 @@
+/**
+ * 错误台账(error ledger):把"服务器侧异常"变成可审计、可报警的持久记录。
+ *
+ * 生产落地语义:任何 5xx / 进程级故障 / 插件装载失败都必须在 /logs(system 域,level=error)
+ * 留下一条可追溯记录 —— 人读一行摘要 + 完整堆栈进 detail_json。此前这些异常只进 console
+ * (进程重启即失),运维在日志页看不到"系统到底什么时候坏过、坏在哪"。
+ *
+ * 三个入口:
+ *  - captureServerError(event, error):nitro 'error' 钩子接线(未捕获异常 / 5xx 响应)
+ *  - captureProcessFault(kind, reason):unhandledRejection / uncaughtException(dev-stability-guard 转接)
+ *  - capturePluginError(scope, err):插件宿主初始化 / 单插件装载失败(aw-plugins 转接)
+ *
+ * 设计约束(全部为硬要求):
+ *  - 限流去重:同 key(method+path+消息指纹)10s 折叠;全局 120 条/分钟,超限丢弃并计，
+ *    每 60s 补一条"节流"汇总记录 —— 异常风暴时台账既不失真也不被打爆。
+ *  - 自身永不抛错:台账写失败只 console.warn,绝不击穿业务主链路(与 recordOps 同纪律)。
+ *  - 只记 system 域 level=error(进程瞬态 socket/db-busy 降为 warn,与 stability-severity 对齐)。
+ */
+import { recordOps } from './ops'
+import { classifyFatalCandidate } from '../../../utils/stability-severity'
+
+/** 单 key 折叠窗:同源异常 10s 内只记首条 */
+const DEDUP_WINDOW_MS = 10_000
+/** 全局限流:每分钟最多入账条数(超出丢弃,防异常风暴打爆 sqlite) */
+const RATE_LIMIT_PER_MIN = 120
+/** 节流汇总记录的最小间隔 */
+const THROTTLE_SUMMARY_INTERVAL_MS = 60_000
+/** 堆栈截断上限(完整 4KB 足够定位;超长栈多为递归渲染噪声) */
+const STACK_MAX_CHARS = 4096
+
+const dedupMap = new Map<string, number>()
+let windowStart = 0
+let windowCount = 0
+let droppedCount = 0
+// 初始取当前时刻:汇总行只在"持续丢弃满一个汇总间隔"后出现,
+// 个别折叠不产生噪声行(否则折叠语义被自我抵消)
+let lastThrottleSummaryAt = Date.now()
+
+/** 测试隔离:清空全部限流状态(仅测试调用) */
+export function resetErrorLedgerForTest(): void {
+  dedupMap.clear()
+  windowStart = 0
+  windowCount = 0
+  droppedCount = 0
+  lastThrottleSummaryAt = Date.now()
+}
+
+function truncate(text: string, max: number): string {
+  return text.length <= max ? text : `${text.slice(0, max)}…(截断,原长 ${text.length})`
+}
+
+/** 限流判定:返回 false = 该条应被折叠/丢弃 */
+function admit(key: string, now: number): boolean {
+  const last = dedupMap.get(key)
+  if (last !== undefined && now - last < DEDUP_WINDOW_MS) return false
+  dedupMap.set(key, now)
+  if (dedupMap.size > 512) {
+    // 简单防膨胀:清掉 30s 前的旧 key(异常源不会长期驻留)
+    for (const [k, ts] of dedupMap) {
+      if (now - ts > 30_000) dedupMap.delete(k)
+    }
+  }
+  if (now - windowStart >= 60_000) {
+    windowStart = now
+    windowCount = 0
+  }
+  windowCount += 1
+  return windowCount <= RATE_LIMIT_PER_MIN
+}
+
+function noteDropped(now: number): void {
+  droppedCount += 1
+  if (now - lastThrottleSummaryAt >= THROTTLE_SUMMARY_INTERVAL_MS) {
+    lastThrottleSummaryAt = now
+    writeSafe({
+      action: 'server.error.throttled',
+      summary: `错误台账节流:过去窗口丢弃 ${droppedCount} 条重复/超限异常(限流 ${RATE_LIMIT_PER_MIN}/min)`,
+      detail: { droppedCount, rateLimitPerMin: RATE_LIMIT_PER_MIN },
+      level: 'warn',
+    })
+    droppedCount = 0
+  }
+}
+
+interface LedgerInput {
+  action: string
+  summary: string
+  detail: Record<string, unknown>
+  level?: 'info' | 'warn' | 'error'
+}
+
+/** 统一出账:recordOps 包一层永不抛错(审计失败不击穿,与全站纪律一致) */
+function writeSafe(entry: LedgerInput): void {
+  try {
+    recordOps({
+      actor: 'error-ledger',
+      actorName: '错误台账',
+      actorKind: 'system',
+      action: entry.action,
+      kind: 'system',
+      scope: 'system',
+      level: entry.level ?? 'error',
+      summary: entry.summary,
+      detail: entry.detail,
+      targetKind: 'server',
+    })
+  }
+  catch (err) {
+    console.warn(`[error-ledger] 台账写入失败(已忽略): ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+/** 从任意 thrown 值提取 { name, message, stack } 结构(thrown 不一定是 Error) */
+function describeThrown(reason: unknown): { name: string, message: string, stack: string } {
+  if (reason instanceof Error) {
+    return { name: reason.name, message: reason.message, stack: truncate(reason.stack ?? '', STACK_MAX_CHARS) }
+  }
+  return { name: 'NonErrorThrow', message: truncate(String(reason), 500), stack: '' }
+}
+
+/** h3 事件的最小结构面(避免把 h3 类型耦合进纯服务层,便于单测) */
+export interface LedgerEventLike {
+  method?: string
+  path?: string | undefined
+  /** h3 event 上原始 node 请求 */
+  node?: { req?: { method?: string, url?: string } }
+}
+
+function requestOf(event: LedgerEventLike | undefined): { method: string, path: string } {
+  const method = String(event?.method ?? event?.node?.req?.method ?? 'GET').toUpperCase()
+  const path = String(event?.path ?? event?.node?.req?.url ?? '(unknown)')
+  return { method, path }
+}
+
+/**
+ * nitro 'error' 钩子入口:只记 /api/** 且 statusCode>=500(4xx 是被拦截的业务语义,
+ * 数量巨大且已由各路由给出可行动回执 —— 入账反而淹没真错误)。
+ */
+export function captureServerError(event: LedgerEventLike | undefined, error: unknown): void {
+  try {
+    const { method, path } = requestOf(event)
+    if (!path.startsWith('/api/')) return
+    const status = (error as { statusCode?: number })?.statusCode
+    if (typeof status === 'number' && status < 500) return
+    const now = Date.now()
+    const info = describeThrown(error)
+    const key = `${method} ${path} ${info.name}:${info.message.slice(0, 120)}`
+    if (!admit(key, now)) {
+      noteDropped(now)
+      return
+    }
+    writeSafe({
+      action: 'server.error',
+      summary: `${method} ${path} → ${status ?? 500} ${info.name}: ${truncate(info.message, 200)}`,
+      detail: { method, path, status: status ?? 500, name: info.name, message: info.message, stack: info.stack },
+    })
+  }
+  catch (err) {
+    console.warn(`[error-ledger] captureServerError 自身异常(已忽略): ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+/**
+ * 进程级故障入口(dev-stability-guard 转接):severity 与 stability-severity 对齐 ——
+ * fatal/upstream/engine → error;socket/db-busy 瞬态 → warn。fatal 分支在 exit 前调用,
+ * sqlite 同步写保证落账先于进程退出。
+ */
+export function captureProcessFault(kind: 'unhandledRejection' | 'uncaughtException', reason: unknown): void {
+  try {
+    const now = Date.now()
+    const info = describeThrown(reason)
+    const severity = classifyFatalCandidate(reason)
+    const key = `process ${kind} ${info.name}:${info.message.slice(0, 120)}`
+    if (!admit(key, now)) {
+      noteDropped(now)
+      return
+    }
+    writeSafe({
+      action: `process.${kind}`,
+      summary: `进程${kind === 'uncaughtException' ? '未捕获异常' : '未处理的 Promise 拒绝'}[${severity}] ${info.name}: ${truncate(info.message, 200)}`,
+      detail: { kind, severity, name: info.name, message: info.message, stack: info.stack },
+      level: severity === 'socket' || severity === 'db-busy' ? 'warn' : 'error',
+    })
+  }
+  catch (err) {
+    console.warn(`[error-ledger] captureProcessFault 自身异常(已忽略): ${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+/** 插件宿主/装载失败入口(aw-plugins 转接):插件面故障必须进台账 */
+export function capturePluginError(scope: string, err: unknown): void {
+  try {
+    const now = Date.now()
+    const info = describeThrown(err)
+    const key = `plugin ${scope} ${info.name}:${info.message.slice(0, 120)}`
+    if (!admit(key, now)) {
+      noteDropped(now)
+      return
+    }
+    writeSafe({
+      action: 'plugin.error',
+      summary: `插件故障[${scope}] ${info.name}: ${truncate(info.message, 200)}`,
+      detail: { scope, name: info.name, message: info.message, stack: info.stack },
+    })
+  }
+  catch (e) {
+    console.warn(`[error-ledger] capturePluginError 自身异常(已忽略): ${e instanceof Error ? e.message : String(e)}`)
+  }
+}

package/server/services/workshop/optimization/profile-adopt.service.ts

@@ -19,7 +19,9 @@ import { recordOps } from '../ops/ops'
 import { getProfileRepo, parseProfileRow } from './profile.repo'
 import { getBindingRepo } from './binding.repo'
 import { assertProfileSolverCompatible, type OptimizationProfile } from './contracts'
-import type { ProblemTemplateRef, SolverRef } from '../process-model/contracts'
+import type { ProblemTemplateRef, SolverRef, ProcessModelSpec } from '../process-model/contracts'
+import { getProcessModelSpecRepo } from '../process-model/spec.repo'
+import { parseProcessModelSpec } from '../process-model/spec'
 import { securityRecipeDispatchTimeoutMs } from '../settings'
 import { createLogger } from '../logger'
 
@@ -33,6 +35,15 @@ export function isProfileAdoptCard(nodeId: string): boolean {
   return nodeId.startsWith(PROFILE_ADOPT_PREFIX)
 }
 
+/** 解析 Profile 引用的 ProcessModelSpec(id[@version];与 manager.loadSpec 同语义)。 */
+function loadAdoptSpec(ref: string): ProcessModelSpec {
+  const [id, versionText] = ref.split('@')
+  if (!id) throw new AppError(422, 'PROFILE_SPEC_MISSING', 'Profile 未引用 ProcessModelSpec(processSpecRef 为空),无法校验模型血缘')
+  const row = getProcessModelSpecRepo().get(id, versionText ? Number(versionText) : undefined)
+  if (!row) throw new AppError(404, 'SPEC_NOT_FOUND', `ProcessModelSpec ${ref} 不存在`)
+  return parseProcessModelSpec(JSON.parse(row.specJson))
+}
+
 export interface ProposeAdoptionInput {
   /** 发起 Agent 的 channel 实例 id(HITL 卡挂在其频道) */
   agentInstanceId: string
@@ -75,8 +86,23 @@ export async function proposeProfileAdoption(input: ProposeAdoptionInput): Promi
   }
   const model = getAmlRuntime().repo.model.get(input.modelId)
   if (!model) throw new AppError(404, 'MODEL_NOT_FOUND', `模型 ${input.modelId} 不存在(先经 AML 训练登记)`)
-
   const prior = parseProfileRow(published)
+
+  // 血缘一致性(2026-10-29):采纳的模型必须与 Profile 场景规格同产线/同产品/同配方 ——
+  // 防止把别的产品/配方训练的模型工件挂进本场景求解(数据串味的最后一道结构闸)。
+  // 训练数据按隔离三元组构建(dataset-builder 硬校验),这里按同一三元组对齐。
+  const adoptSpec = loadAdoptSpec(prior.processSpecRef)
+  const adoptDataset = getAmlRuntime().repo.dataset.get(model.datasetId)
+  if (!adoptDataset) {
+    throw new AppError(422, 'MODEL_LINEAGE_MISSING', `模型 ${input.modelId} 缺少数据集谱系(dataset ${model.datasetId} 不存在),无法核验训练数据归属;拒绝采纳`)
+  }
+  if (adoptDataset.lineId !== adoptSpec.lineId) {
+    throw new AppError(422, 'MODEL_LINE_MISMATCH', `模型 ${input.modelId} 训练数据归属产线 ${adoptDataset.lineId},与 Profile 场景产线 ${adoptSpec.lineId} 不一致;跨产线模型禁止采纳`)
+  }
+  if (model.productId !== adoptSpec.productId || model.recipeId !== adoptSpec.recipeId) {
+    throw new AppError(422, 'MODEL_PRODUCT_MISMATCH', `模型 ${input.modelId} 训练于 (产品 ${model.productId}, 配方 ${model.recipeId}),与 Profile 场景 (产品 ${adoptSpec.productId}, 配方 ${adoptSpec.recipeId}) 不一致;跨产品/配方模型禁止采纳(防串味)`)
+  }
+
   const version = published.version + 1
   const nextProfile: OptimizationProfile = {
     ...prior,

package/server/services/workshop/plugins/host/init.mjs

@@ -35,6 +35,10 @@ export async function initPluginHost({ cwd = process.cwd(), packageRoot } = {})
   // 有效配置(只读面;引擎/模式解析从运行根动态加载)
   let config = null
   let settingsPath = null
+  // 未掩码内部消费面:插件 ctx.config 必须读真值(rag-bridge/diag-bridge 的出站 token)。
+  // 不能用 system-config 广播里的 tail.effective —— 那是出口面(凭据已掩码为 ***),
+  // 合并进插件 ctx.config 会让插件读到 *** 而不是真 token(2026-10-30 P1-3 掩码
+  // 加固后的回归:本机桥接全部 401)。内部消费面走 SystemConfigService.internalEffective()。
   let paths = { home: homeDir, configRoot: join(cwd, '.AgentWorkShop'), dataDir: join(cwd, '.AgentWorkShop', 'data') }
   try {
     // home.mjs 探测根:cwd 优先;cwd 漂移(计划任务/服务方式启动,schtasks 默认 System32、
@@ -55,17 +59,23 @@ export async function initPluginHost({ cwd = process.cwd(), packageRoot } = {})
     }
     paths = { home: rm.home, configRoot: rm.configRoot, dataDir: rm.dataDir }
     host.logger.info(`配置根: ${rm.configRoot} (${rm.mode} 模式)`)
+    // 2026-10-31:把解析结果存到 host 上,供 reload 复用(reload 自算 cwd 相对路径
+    // 会在 home 模式下把插件 ctx.paths 带回仓库根,daq-export/diag 数据集 ENOENT)。
+    host.paths = paths
   }
   catch (err) {
     host.logger.warn('配置引擎加载降级(插件 ctx.config 将为空):', err?.message)
   }
   // 配置热更新:system-config 变化(设置页 PATCH / runtime-settings 文件监听)即刷新
   // effective —— 插件 ctx.config.get 每次调用实时读到新值(插件 API 地址等改配置即生效,无需重启)
+  let configService = null
   try {
     const { getSystemConfigService } = await import('@/server/services/system-config')
-    getSystemConfigService().subscribe((tail) => {
+    configService = getSystemConfigService()
+    configService.subscribe(() => {
       try {
-        if (config?.effective && tail?.effective) Object.assign(config.effective, tail.effective)
+        if (!config?.effective || !configService) return
+        Object.assign(config.effective, configService.internalEffective())
       }
       catch { /* 刷新失败保留旧值 */ }
     })
@@ -94,6 +104,15 @@ export async function initPluginHost({ cwd = process.cwd(), packageRoot } = {})
 
   await loadAllPlugins(host, { config, settingsPath, paths })
   await syncPluginSettings()
+  // 插件 settings 描述符在装载期才注册进 SystemConfigService(engine.loadEffective 的
+  // 静态描述符表里没有 plugins.* 键)→ 装载完成后再从服务同步一次未掩码 effective,
+  // 让 ctx.config.get('plugins.<name>.token') 从第一次调用起就能读到真值。
+  try {
+    if (config?.effective && configService) Object.assign(config.effective, configService.internalEffective())
+  }
+  catch (err) {
+    host.logger.warn('插件设置初值同步失败:', err?.message ?? err)
+  }
   relayConfigEvents(host)
   ensureStateWatcher(host)
   return host

package/server/services/workshop/plugins/host/reload.mjs

@@ -77,7 +77,14 @@ export async function doReload(host) {
   host.plugins.clear()
   host.routes = createRouteTable()
   host.failures = []
-  await loadAllPlugins(host, { config: host.config, settingsPath: null, paths: { home: modePaths(host.cwd).homeDir, configRoot: join(host.cwd, '.AgentWorkShop'), dataDir: join(host.cwd, '.AgentWorkShop', 'data') } })
+  // 2026-10-31 修复(home 模式路径回归):重载路径此前硬编码 join(host.cwd,'.AgentWorkShop')
+  // —— repo 模式恰好重合所以从未暴露;home/隔离模式(AW_HOME≠repo)下,设置热更触发重载后
+  // 插件 ctx.paths.dataDir 落到仓库数据根,diag_run 读 daq-export 数据集 ENOENT
+  // (daq_export 由平台服务写 AW_HOME/data,两边根不一致;实测 iddrag-e2e 抓获)。
+  // init.mjs 已按 resolveRunMode 解析正确根并存 host.paths;重载必须复用,不得自算。
+  const reloadPaths = host.paths
+    ?? { home: modePaths(host.cwd).homeDir, configRoot: join(host.cwd, '.AgentWorkShop'), dataDir: join(host.cwd, '.AgentWorkShop', 'data') }
+  await loadAllPlugins(host, { config: host.config, settingsPath: null, paths: reloadPaths })
   // 装载中途失败(setup 抛错)的插件可能留下半注册工具,兜底再清一次
   for (const prev of prevNames) {
     if (!host.plugins.has(prev)) {

package/server/services/workshop/runtime/agent-runtime/harness-failure.ts

@@ -0,0 +1,58 @@
+/**
+ * harness 回合失败分类与熔断(2026-10-30 缺陷修复:LLM 预算耗尽任务假活)。
+ *
+ * 问题:预算耗尽/凭据失效这类"重试不可能成功"的回合失败,此前走既有重投链
+ * (每消息 ≤2 次)后任务虽会落 FAILED,但新派发/监督回合继续打死供应商,
+ * 任务反复假活,运维只能翻日志发现"预算墙"。
+ *
+ * 机制(纯函数,无状态;状态由 AgentRuntime 持有):
+ *   分类 → 连败串(同类累加/异类重置) → 终态类达阈值即熔断:
+ *   当前 WORKING 任务按 HARNESS_UNAVAILABLE_* 收口 + 停止重投;
+ *   冷却窗(默认 5min)过后自动半开,允许一次探测回合——成功即复位,再失败立即重新熔断。
+ */
+
+export type HarnessFailureClass = 'budget' | 'auth' | 'model' | 'network' | 'other'
+
+/** 人工干预才可能恢复的类别(预算/凭据/模型配置)——重试无意义,触发熔断 */
+export const HARNESS_TERMINAL_CLASSES: ReadonlySet<HarnessFailureClass> = new Set(['budget', 'auth', 'model'])
+
+/** 连续同类终态失败达到该次数 → 熔断 */
+export const HARNESS_FAIL_STREAK_LIMIT = 3
+
+/** 熔断后半开冷却:距最后一次失败超过该时长,放行探测回合(成功复位/再失败立即重新熔断) */
+export const HARNESS_FAIL_COOLDOWN_MS = 5 * 60_000
+
+/** 回合失败分类:code+message 合并小写后按特征归类(network 允许重试,不参与熔断) */
+export function classifyHarnessFailure(code: string, message: string): HarnessFailureClass {
+  const m = `${code} ${message}`.toLowerCase()
+  if (/422|budget/.test(m)) return 'budget'
+  if (/401|403|unauthorized|forbidden|invalid[ _-]?api[ _-]?key|api[ _-]?key/.test(m)) return 'auth'
+  if (/404|model not found|no such model|not_found/.test(m)) return 'model'
+  if (/econn|etimedout|timeout|rpc_broken|spawn|fetch failed|network/.test(m)) return 'network'
+  return 'other'
+}
+
+export interface HarnessFailStreak {
+  cls: HarnessFailureClass
+  count: number
+  lastAt: number
+}
+
+/** 更新连败串:同类累加,异类重置为 1(全新问题重新计数) */
+export function recordHarnessFailure(prev: HarnessFailStreak | null, cls: HarnessFailureClass, now = Date.now()): HarnessFailStreak {
+  return prev && prev.cls === cls
+    ? { cls, count: prev.count + 1, lastAt: now }
+    : { cls, count: 1, lastAt: now }
+}
+
+/**
+ * 熔断是否生效:终态类 + 达阈值 + 处于冷却窗内。
+ * 冷却窗外(超过 HARNESS_FAIL_COOLDOWN_MS 未失败)自动半开放行探测,
+ * 探测失败会经 recordHarnessFailure 刷新 lastAt 立即重新生效。
+ */
+export function harnessBreakerActive(streak: HarnessFailStreak | null, now = Date.now()): boolean {
+  if (!streak) return false
+  if (!HARNESS_TERMINAL_CLASSES.has(streak.cls)) return false
+  if (streak.count < HARNESS_FAIL_STREAK_LIMIT) return false
+  return now - streak.lastAt < HARNESS_FAIL_COOLDOWN_MS
+}

package/server/services/workshop/runtime/agent-runtime/message.ts

@@ -8,6 +8,7 @@ import type { AgentContextStats, AgentStatusView } from '../../types/task'
 import type { AgentRunContext, AgentRunRequest } from '../../agents/agent-interface'
 import { TERMINAL_TASK_STATES } from '../../types/task'
 import { log, partsToText } from './helpers'
+import { classifyHarnessFailure, harnessBreakerActive, recordHarnessFailure, HARNESS_FAIL_COOLDOWN_MS, HARNESS_FAIL_STREAK_LIMIT } from './harness-failure'
 import { fenceFromMetadata } from '../task-engine/lease'
 import type { ExecutionFence } from '../task-engine/lease'
 import { randomUUID } from 'node:crypto'
@@ -48,6 +49,7 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
     let repliedToRequester = false
     /** 失败原因(事件 error / 生成器抛错):写入任务 history,供事后诊断 */
     let runErrorMessage = ''
+    let runErrorCode = ''
     try {
       // 任务消息联动:assign → WORKING(自动接取;状态事件由 TaskEngine transition hooks 广播)
       // 仅 SUBMITTED/ASSIGNED 自动接取:WAITING(已有子任务)的任务由 SchedulerLoop/子任务汇总推进,
@@ -115,7 +117,10 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
           }
           if (event.kind === 'error') {
             sawRunError = true
-            if (!runErrorMessage) runErrorMessage = `${event.error.code}: ${event.error.message}`
+            if (!runErrorMessage) {
+              runErrorCode = String(event.error.code ?? '')
+              runErrorMessage = `${event.error.code}: ${event.error.message}`
+            }
           }
           // 无原生工具面的 harness(codex/dsh 等)以 shell/文本方式作业:回合 error 收束
           // 但已有实质输出时,不落入 FAILED(交由回合结束后的交付兜底按最终输出隐式收口)——
@@ -140,6 +145,7 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
       catch (err) {
         // run 生成器抛错(如 omp 子进程 spawn 失败):按回合失败走重投,不外抛断循环
         sawRunError = true
+        runErrorCode = 'RUN_ERROR'
         runErrorMessage = err instanceof Error ? err.message : String(err)
         // Harness 重建归因(§6.2):下回合若换了 client/进程,原因取自此处
         this.pendingHarnessFailure = 'RPC_BROKEN'
@@ -345,7 +351,36 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
       // 由调度器 reassign/新 assign 驱动,重投只会空转(启动即被终态检查消费)。
       const taskNow = taskId ? this.deps.taskEngine.get(taskId) : undefined
       const taskDone = !!taskNow && TERMINAL_TASK_STATES[taskNow.state]
-      if (sawRunError && !taskDone && (this.runErrorRetries.get(msg.messageId) ?? 0) < 2
+      // ── 缺陷2修复:harness 回合失败分类熔断(2026-10-30)──
+      // 预算/凭据/模型缺失这类"重试不可能成功"的失败,连续达阈值即:
+      // 当前 WORKING 任务按 HARNESS_UNAVAILABLE_* 收口(原因入 history)+ 停止重投,
+      // 防"任务假活 + 无意义重试打供应商"。冷却窗(5min)后半开:放行探测回合,
+      // 成功整串复位;再失败立即重新熔断。network 等可重试类别不参与熔断。
+      let stopRetry = false
+      if (sawRunError) {
+        const cls = classifyHarnessFailure(runErrorCode, runErrorMessage)
+        const streak = recordHarnessFailure(this.harnessFailStreak, cls)
+        this.harnessFailStreak = streak
+        if (harnessBreakerActive(streak)) {
+          stopRetry = true
+          if (taskNow && taskNow.state === 'WORKING' && taskId) {
+            this.deps.taskEngine.applyEvent(taskId, {
+              kind: 'error',
+              error: {
+                code: `HARNESS_UNAVAILABLE_${cls.toUpperCase()}`,
+                message: `harness 连续 ${streak.count} 次 ${cls} 类失败(${String(runErrorMessage ?? '').slice(0, 200)})——熔断收口:停止自动重试;排除预算/凭据/模型问题后重新派发即可恢复`,
+              },
+            }, fence)
+          }
+          if (streak.count === HARNESS_FAIL_STREAK_LIMIT) {
+            log.error(`[AgentRuntime:${this.agentId}] harness 失败熔断(${cls} ×${streak.count}):任务按失败收口并停止重投;${Math.round(HARNESS_FAIL_COOLDOWN_MS / 60_000)} 分钟后半开探测`)
+          }
+        }
+      }
+      else {
+        this.harnessFailStreak = null
+      }
+      if (sawRunError && !taskDone && !stopRetry && (this.runErrorRetries.get(msg.messageId) ?? 0) < 2
         && this.deps.mailbox.requeue(msg.messageId)) {
         const attempt = (this.runErrorRetries.get(msg.messageId) ?? 0) + 1
         this.runErrorRetries.set(msg.messageId, attempt)

package/server/services/workshop/runtime/agent-runtime/state.ts

@@ -22,6 +22,8 @@ export abstract class AgentRuntimeState extends AgentRuntimeContracts {
   protected state: 'idle' | 'busy' | 'stopped' = 'idle'
   /** 回合失败重投计数(每消息;进程内存,重启由 resetConsuming 重新给机会) */
   protected runErrorRetries = new Map<string, number>()
+  /** harness 连败串(分类熔断;成功回合复位,冷却窗后半开放行探测) */
+  protected harnessFailStreak: import('./harness-failure').HarnessFailStreak | null = null
   /** 正在执行的任务 id(run 期间;空闲时 null) */
   protected currentTaskId: string | null = null
   /** poll_messages 阻塞等待数(waitPending 活动计数;>0 = 有轮询在等,实时消息留信箱由其取走) */
@@ -264,9 +266,17 @@ export abstract class AgentRuntimeState extends AgentRuntimeContracts {
 
   /** 仅中止仍在执行指定任务的当前 run;不影响其它任务或 supervise 回合 */
   abortTask(taskId: string): boolean {
-    if (this.currentTaskId !== taskId) return false
+    const abortingRun = this.currentTaskId === taskId
+    const abortingSupervision = this.supervisionAttempt.activeRootId === taskId
+      && this.hasActiveSupervisionAttempt()
+    if (!abortingRun && !abortingSupervision) return false
     log.warn(`[AgentRuntime:${this.agentId}] abortTask 调用(task=${taskId},state=${this.state})`)
-    this.abortController?.abort()
+    if (abortingRun) this.abortController?.abort()
+    if (abortingSupervision) {
+      this.supervisionAttempt = { ...this.supervisionAttempt, state: 'ABORT_REQUESTED' }
+      this.superviseController?.abort()
+      this.refreshStatus()
+    }
     return true
   }
 

package/server/services/workshop/runtime/agent-runtime/types.ts

@@ -133,6 +133,8 @@ export interface TaskEngine {
   list(channelId: string): WorkspaceTask[]
   get(taskId: string): WorkspaceTask | undefined
   complete(taskId: string, artifacts?: A2AArtifact[]): WorkspaceTask
+  /** 显式替代:FAILED/CANCELED 分支被 replacement 覆盖(父任务收口前置处置;整改计划 2026-10-30 阶段1) */
+  supersede(taskId: string, replacementTaskId: string, by: string, reason?: string): WorkspaceTask
   reassign(taskId: string, toAgentId: string, reason?: string): WorkspaceTask
   /** §5.2 运行中重分配(WORKING/WAITING;撤销旧 lease + generation+1 + 新 assign) */
   reassignRunning(taskId: string, toAgentId: string, by: string, reason?: string): { task: WorkspaceTask, previousAssigneeId: string }

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

@@ -28,6 +28,11 @@ export class ChannelRuntime {
   readonly channelId: string
   private agents = new Map<string, AgentRuntimeLike>()
   private schedulerLoop: SchedulerLoopLike | null = null
+  /** All loops ever attached during this ChannelRuntime lifetime; the pointer alone can hide an overwritten loop. */
+  private readonly schedulerLoops = new Set<SchedulerLoopLike>()
+  private schedulerStopLeaseCount = 0
+  private schedulerStopFailureLatched = false
+  private schedulerStopBarrier: Promise<void> | null = null
   /** 懒加载回调(manager 注入);未装配的收件人经此按需 wire */
   private loader: AgentLoader | null = null
 
@@ -205,11 +210,85 @@ export class ChannelRuntime {
   }
 
   set scheduler(loop: SchedulerLoopLike | null) {
+    if (!loop) {
+      if (this.schedulerLoop) this.schedulerLoops.delete(this.schedulerLoop)
+      this.schedulerLoop = null
+      return
+    }
     this.schedulerLoop = loop
+    this.schedulerLoops.add(loop)
   }
 
   get scheduler(): SchedulerLoopLike | null {
-    return this.schedulerLoop
+    return this.schedulerLoop ?? this.schedulerLoops.values().next().value ?? null
+  }
+
+  get schedulerStoppingInProgress(): boolean {
+    return this.schedulerStopLeaseCount > 0 || this.schedulerStopFailureLatched
+  }
+
+  /**
+   * Stop every attached loop and return a lease that keeps replacements gated until teardown ends.
+   * The owner must release it after dependent runtimes are detached; a stop failure leaves the gate closed.
+   */
+  async stopSchedulersAndWait(): Promise<() => void> {
+    this.schedulerStopLeaseCount += 1
+    let released = false
+    const release = () => {
+      if (released) return
+      released = true
+      this.schedulerStopLeaseCount = Math.max(0, this.schedulerStopLeaseCount - 1)
+    }
+    try {
+      await this.stopSchedulerBarrier()
+    }
+    catch (error) {
+      release()
+      throw error
+    }
+    return release
+  }
+
+  /** Coalesce concurrent stops so one failed barrier cannot race a successful retry's recovery. */
+  private stopSchedulerBarrier(): Promise<void> {
+    if (this.schedulerStopBarrier) return this.schedulerStopBarrier
+
+    const barrier = (async () => {
+      while (this.schedulerLoops.size > 0) {
+        const loops = [...this.schedulerLoops]
+        const results = await Promise.allSettled(loops.map(loop => loop.stopAndWait()))
+        let failure: unknown
+        let failed = false
+        for (const [index, result] of results.entries()) {
+          const loop = loops[index]!
+          if (result.status === 'fulfilled') {
+            this.schedulerLoops.delete(loop)
+          }
+          else if (!failed) {
+            failed = true
+            failure = result.reason
+          }
+        }
+        this.schedulerLoop = this.schedulerLoops.values().next().value ?? null
+        if (failed) throw failure
+      }
+      this.schedulerLoop = null
+    })()
+      .then(() => {
+        // A complete retry proves every still-tracked loop has stopped. Active leases remain held.
+        this.schedulerStopFailureLatched = false
+      })
+      .catch((error: unknown) => {
+        // Keep scheduler starts fail-closed until a later complete barrier succeeds.
+        this.schedulerStopFailureLatched = true
+        throw error
+      })
+      .finally(() => {
+        if (this.schedulerStopBarrier === barrier) this.schedulerStopBarrier = null
+      })
+
+    this.schedulerStopBarrier = barrier
+    return barrier
   }
 
   /** 唤醒调度循环(事件驱动) */