agentworkshop 0.8.6 → 0.8.8

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

@@ -82,8 +82,14 @@ export abstract class SchedulerLoopTick extends SchedulerLoopState {
       const deferrable = hitlPending
         ? expiredRoots.filter(r => (this.hitlDeferrals.get(r.id) ?? 0) < MAX_HITL_DEFERRALS)
         : []
-      if (deferrable.length > 0 && deferrable.length === expiredRoots.length) {
+      if (deferrable.length > 0) {
+        // 2026-10-30 修复:原实现要求「全部可顺延」(deferrable.length === expiredRoots.length)
+        // 才顺延 —— 只要有一根达顺延上限,连仍受审批保护的根一起 ROOT_TIMEOUT 处决,
+        // 留下悬空审批单(人类随后批准,决议落在已死树上,审批面无任务可归)。
+        // 改为逐根分流:可顺延的刷新预算(消耗一次顺延),已达上限的照常收口 ——
+        // 与"人类思考期不应处决受审批保护的树"语义逐根对齐。
         const budget = new Date(Date.now() + (Number(workshopSettings().root_timeout_ms) || 900_000)).toISOString()
+        const deferredIds = new Set(deferrable.map(r => r.id))
         for (const root of deferrable) {
           this.hitlDeferrals.set(root.id, (this.hitlDeferrals.get(root.id) ?? 0) + 1)
           if (!this.hitlDeferred.has(root.id)) {
@@ -97,6 +103,16 @@ export abstract class SchedulerLoopTick extends SchedulerLoopState {
           }
           catch { /* 任务恰好终态:下一 tick 自然收敛 */ }
         }
+        for (const root of expiredRoots) {
+          if (deferredIds.has(root.id)) continue
+          const closed = this.lead.taskEngine.timeoutTree(root.id, this.lead.agentId)
+          for (const task of closed) {
+            this.channelRuntime.getAgents().find(a => a.agentId === task.assigneeId)?.abortTask?.(task.id)
+          }
+          // 已收口的根清掉顺延记账(与下方全清语义一致,只是范围收窄到本轮处决的根)
+          this.hitlDeferrals.delete(root.id)
+          this.hitlDeferred.delete(root.id)
+        }
         this.lead.refreshStatus()
         return
       }
@@ -175,7 +191,17 @@ export abstract class SchedulerLoopTick extends SchedulerLoopState {
     if (this.lead.supervise === null) return false // no Lead decision capability: recovery only
     if (this.lastSuperviseAt === 0) return true
     const fingerprint = this.superviseFingerprint(snapshot)
-    if (fingerprint !== this.lastFingerprint) return true
+    if (fingerprint !== this.lastFingerprint) {
+      const [, previousMembers, previousMail] = this.lastFingerprint.split('#')
+      const [, currentMembers, currentMail] = fingerprint.split('#')
+      const activeRoot = snapshot.activeRootId ? snapshot.tasks.find(t => t.id === snapshot.activeRootId) : null
+      const activeRootAlive = Boolean(activeRoot) && !TERMINAL_TASK_STATES[activeRoot!.state]
+      const terminalTaskOnlyChange = snapshot.tasks.every(task => TERMINAL_TASK_STATES[task.state])
+        && !activeRootAlive
+        && previousMembers === currentMembers
+        && previousMail === currentMail
+      if (!terminalTaskOnlyChange) return true
+    }
 
     // Retry incomplete acceptance periodically, including the WORKING parent state
     // used after the final child completes.
@@ -203,7 +229,9 @@ export abstract class SchedulerLoopTick extends SchedulerLoopState {
 
   protected lastCloseOutAt = 0
 
-  /** 存在子任务已全部终态但尚未由 Lead 明确验收的 WAITING 父任务 */
+  /** 存在子任务已全部终态但尚未由 Lead 明确验收的父任务。
+   *  口径=「全部终态即提醒」:失败/取消分支此刻正是需要 Lead 行动的信号——
+   *  Lead 拥有 supersede(显式替代)工具可处置后再收口(整改计划阶段1 F2)。 */
   protected hasReviewableParent(snapshot: SupervisionSnapshot): boolean {
     return snapshot.tasks.some((t) => {
       if ((t.state !== 'WAITING' && t.state !== 'WORKING') || t.assigneeId !== this.lead.agentId) return false

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

@@ -4,7 +4,7 @@
  */
 import { TaskEngineUpdate } from './update'
 import type { Part } from '../../types/a2a'
-import type { WorkspaceTask } from '../../types/task'
+import { TERMINAL_TASK_STATES, type WorkspaceTask } from '../../types/task'
 import { AppError } from '../../../../utils/errors'
 import { rowToTask } from './helpers'
 import { assertDispatchAllowed, rootLineage } from './policy'
@@ -94,6 +94,20 @@ export abstract class TaskEngineCreate extends TaskEngineUpdate {
   ): WorkspaceTask {
     // TaskEngine 是所有派发入口的最终预算闸门；Manager/host tool 的提示不能替代它。
     assertDispatchAllowed(this.repos.tasks, parent)
+    // 2026-10-30 修复(引擎直调路径的状态前置):manager.dispatchTask 有「终态先拒 +
+    // SUBMITTED/ASSIGNED 先接取」前置(manager/tasks.ts:199-210),但调度器
+    // execute('dispatch') 直调引擎时绕过它 —— 父任务为 ASSIGNED(人类直发 worker 的
+    // 根任务未被接取)时,子任务已创建/assign 已外投,末尾 ASSIGNED→WAITING 才抛
+    // INVALID_TRANSITION(不在 TRANSITIONS)→ 孤儿子任务;父停留 ASSIGNED 不参与
+    // WAITING 收口,预算一到 timeoutTree 连带处决正常执行的子树。
+    // 与 manager 同口径:终态先拒(任何副作用之前),SUBMITTED/ASSIGNED 先接取 WORKING。
+    if (TERMINAL_TASK_STATES[parent.state]) {
+      throw new AppError(409, 'TASK_TERMINAL',
+        `父任务 ${parent.id.slice(0, 8)} 已终态(${parent.state}),无法再派发子任务;请另起根任务,或对失败分支用 reassign/supersede 处置`)
+    }
+    if (parent.state === 'SUBMITTED' || parent.state === 'ASSIGNED') {
+      this.transition(parent.id, 'WORKING', parent.assigneeId)
+    }
     // 根任务 FIFO：只有当前 active root 可以继续拆解；后续 roots 先排队。
     // §11 回滚开关 root_queue_enabled=false 时退回多根并发(不改变 source 幂等与预算)。
     const activeRoot = rootQueueEnabled() ? this.activeRootOf(parent.channelId) : null

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

@@ -49,6 +49,7 @@ export function rowToTask(row: TaskRow): WorkspaceTask {
     sourceChatDeliveryId: row.sourceChatDeliveryId || undefined,
     closeReason: row.closeReason || undefined,
     deadlineAt: row.deadlineAt || undefined,
+    supersededByTaskId: row.supersededByTaskId || undefined,
     assignmentGeneration: row.assignmentGeneration ?? 0,
     executionLeaseId: row.executionLeaseId || undefined,
     executionLeaseAgentId: row.executionLeaseAgentId || undefined,
@@ -80,6 +81,7 @@ export function rowToTaskLite(row: TaskMetaRow): WorkspaceTask {
     sourceChatDeliveryId: row.sourceChatDeliveryId || undefined,
     closeReason: row.closeReason || undefined,
     deadlineAt: row.deadlineAt || undefined,
+    supersededByTaskId: row.supersededByTaskId || undefined,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   }

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

@@ -18,7 +18,11 @@ export abstract class TaskEngineLifecycle extends TaskEngineTransition {
   /** 完成任务:WORKING → COMPLETED(终态)+ 进度置 100(广播由上层 ChannelBus 监听 onTaskEvent 承担);
    *  WAITING → COMPLETED 仅在所有子任务有交付且 Lead 已提交验收总结时允许。
    *  goal 模式父任务收口保底:lead 未自带结构化「目标完成总结」时平台合成同构交付物
-   *  (mock/omp/规则引擎三条完成路径共用此处,确保 goal 完成标志恒存在)。 */
+   *  (mock/omp/规则引擎三条完成路径共用此处,确保 goal 完成标志恒存在)。
+   *
+   *  2026-10-30 证据闸(整改计划阶段1):goal-summary(含平台合成)只是**记录**,不是证据——
+   *  无子任务 Goal 必须有真实交付物(或显式 [policy:no-deliverable]);失败/取消子任务
+   *  经 supersede 显式处置后方可收口。 */
   complete(taskId: string, artifacts?: A2AArtifact[]): WorkspaceTask {
     const task = this.requireTask(taskId)
     if (task.state === 'COMPLETED') return task
@@ -30,16 +34,20 @@ export abstract class TaskEngineLifecycle extends TaskEngineTransition {
       .filter(t => t.parentId === task.id)
     const allArtifacts = [...task.artifacts, ...(artifacts ?? [])]
     const modeInfo = extractTaskMode(task)
-    const hasDeliverable = allArtifacts.some(a => a.name !== 'input'
+    // 证据 = 非输入且非 goal-summary(goal-summary 是平台/lead 的收口记录,可自证,不作数)
+    const hasEvidence = allArtifacts.some(a => a.name !== 'input' && !isGoalSummaryArtifact(a)
       && a.parts.some(p => 'text' in p ? p.text.trim().length > 0 : true))
     if (children.length > 0) {
       // 父任务不是“所有子任务终态”就可完成：worker 的 COMPLETED 只是交付，
       // Leader 必须检查每个交付并提交自己的验收总结后，才可收口父任务。
-      const pending = children.filter(t => t.state !== 'COMPLETED')
+      // 失败/取消分支经 supersede(显式替代)处置后不再阻塞;否则必须显式处置。
+      const pending = children.filter(t => t.state !== 'COMPLETED' && !t.supersededByTaskId)
       if (pending.length > 0) {
-        throw new AppError(400, 'INVALID_STATE', `父任务仍有 ${pending.length} 个未通过验收的子任务(失败/取消也需 Lead 明确处理)`)
+        const detail = pending.map(t => `「${t.title}」(${t.state}${t.supersededByTaskId ? '' : ',未处置'})`).join(', ')
+        throw new AppError(400, 'INVALID_STATE', `父任务仍有 ${pending.length} 个未收口的子任务: ${detail}。请先派发替代任务并调用 supersede 处置失败/取消分支,或给出明确处置`)
       }
       const missingDeliverables = children.filter((child) => {
+        if (child.state !== 'COMPLETED') return false
         const row = this.repos.tasks.findById(child.id)
         if (!row) return true
         const completed = rowToTask(row)
@@ -50,15 +58,21 @@ export abstract class TaskEngineLifecycle extends TaskEngineTransition {
         throw new AppError(400, 'WORKER_DELIVERABLE_MISSING', `子任务缺少可验收交付物: ${missingDeliverables.map(c => c.title).join(', ')}`)
       }
       // goal 模式的显式 complete 决策本身是 Lead 的接受动作；若未附总结，
-      // 下方会合成 goal-summary。普通分解任务必须附 Lead 验收总结。
+      // 下方会合成 goal-summary(仅作记录)。普通分解任务必须附 Lead 验收总结。
       const hasLeadAcceptance = allArtifacts.some(a => a.name !== 'input'
         && a.parts.some(p => 'text' in p ? p.text.trim().length > 0 : true))
       if (!hasLeadAcceptance && modeInfo?.mode !== 'goal') {
         throw new AppError(400, 'LEAD_ACCEPTANCE_REQUIRED', '父任务必须由 Lead 提交验收总结后才能完成')
       }
     }
-    else if (!hasDeliverable && modeInfo?.mode !== 'goal') {
-      throw new AppError(400, 'TASK_DELIVERABLE_REQUIRED', '任务完成前必须提交非空 deliverable/summary artifact')
+    else if (!hasEvidence) {
+      // goal 不再豁免证据闸:显式 [policy:no-deliverable] 的 Goal 才允许无交付收口
+      const policyWaived = modeInfo?.mode === 'goal' && modeInfo.config.completionPolicy === 'no-deliverable'
+      if (!policyWaived) {
+        throw new AppError(400, 'TASK_DELIVERABLE_REQUIRED', modeInfo?.mode === 'goal'
+          ? 'Goal 完成前必须提交真实成果 artifact(平台生成的目标总结不算证据);确无交付的目标请在创建时声明 [policy:no-deliverable]'
+          : '任务完成前必须提交非空 deliverable/summary artifact')
+      }
     }
     // goal 收口保底:已有总结(lead 自写/前置合成)则原样保留
     if (modeInfo?.mode === 'goal') {
@@ -238,6 +252,41 @@ export abstract class TaskEngineLifecycle extends TaskEngineTransition {
     return this.requireTask(taskId)
   }
 
+  /**
+   * 显式替代(整改计划阶段1/F1):把 FAILED/CANCELED 分支标记为被 replacement 覆盖。
+   * 失败事实保留(状态不变),但父任务收口不再被该分支阻塞;替代关系落库可审计。
+   * 前置:仅 FAILED/CANCELED 可被替代;替代任务必须同属一个父任务且自身未被替代。
+   */
+  supersede(taskId: string, replacementTaskId: string, by: string, reason?: string): WorkspaceTask {
+    const task = this.requireTask(taskId)
+    if (!task.parentId) {
+      throw new AppError(400, 'INVALID_STATE', '仅子任务分支可被替代(根任务请走取消/失败语义)')
+    }
+    if (task.state !== 'FAILED' && task.state !== 'CANCELED') {
+      throw new AppError(400, 'INVALID_STATE', `仅失败/取消的分支可标记替代(当前 ${task.state})`)
+    }
+    if (replacementTaskId === task.id) {
+      throw new AppError(400, 'INVALID_STATE', '任务不能被自身替代')
+    }
+    const replacement = this.requireTask(replacementTaskId)
+    if ((replacement.parentId ?? null) !== (task.parentId ?? null)) {
+      throw new AppError(400, 'INVALID_STATE', '替代任务必须与被替代任务同属一个父任务')
+    }
+    if (replacement.supersededByTaskId) {
+      throw new AppError(400, 'INVALID_STATE', '替代任务自身已被其他任务替代,不可作为替代目标')
+    }
+    const updated = this.repos.tasks.update(taskId, {
+      supersededByTaskId: replacementTaskId,
+      closeReason: reason ?? task.closeReason ?? `SUPERSEDED_BY_${replacementTaskId.slice(0, 8)}`,
+    })
+    if (!updated) throw new AppError(404, 'NOT_FOUND', `任务不存在: ${taskId}`)
+    const view = rowToTask(updated)
+    this.hooks?.onTaskChange?.({ taskId, channelId: task.channelId, state: view.state, agentId: by, task: view, reason: reason ?? 'SUPERSEDED' })
+    // 替代完成后,父任务的等待口径可能已满足(最后一个未处置分支被处置):唤醒验收
+    if (task.parentId) this.onChildResolved(task.parentId, task.channelId, by)
+    return view
+  }
+
   /** 普通根任务超时:活动后代取消,根任务以 FAILED 保留明确超时语义。 */
   timeoutTree(taskId: string, by: string): WorkspaceTask[] {
     const root = this.requireTask(taskId)
@@ -302,15 +351,25 @@ export abstract class TaskEngineLifecycle extends TaskEngineTransition {
       kind: 'child-completed',
       childTaskId: child.id,
     })
-    // 统计未完成子任务数(排除 COMPLETED/CANCELED);为 0 即最后一个完成。
+    // 统计未收口子任务数:仅「非终态且未被 supersede」的分支阻塞;全终态/全处置即把父推回
+    // WORKING 给 Lead 验收回合(FAILED/CANCELED 也要推——Lead 的回合正是用来 supersede 的)。
     // 子任务直查(免全 channel 扫描);完成闸门仅需 state → 元数据投影足够。
     const siblings = this.repos.tasks.listChildrenMeta(parent.channelId, parent.id)
-    const incomplete = siblings.filter(t => t.state !== 'COMPLETED' && t.state !== 'CANCELED')
+    const incomplete = siblings.filter(t => t.state !== 'COMPLETED' && t.state !== 'FAILED' && t.state !== 'CANCELED' && !t.supersededByTaskId)
     if (incomplete.length === 0 && parent.state === 'WAITING') {
       this.transition(parent.id, 'WORKING', child.assigneeId)
     }
   }
 
+  /** supersede 后的父任务等待口径复检(与 onChildCompleted 同一过滤口径);满足则 WAITING → WORKING */
+  protected onChildResolved(parentId: string, channelId: string, by: string): void {
+    const parent = this.get(parentId)
+    if (!parent || parent.state !== 'WAITING') return
+    const siblings = this.repos.tasks.listChildrenMeta(channelId, parentId)
+    const incomplete = siblings.filter(t => t.state !== 'COMPLETED' && t.state !== 'FAILED' && t.state !== 'CANCELED' && !t.supersededByTaskId)
+    if (incomplete.length === 0) this.transition(parentId, 'WORKING', by)
+  }
+
   protected requireTask(taskId: string): WorkspaceTask {
     const task = this.get(taskId)
     if (!task) throw new AppError(404, 'NOT_FOUND', `任务不存在: ${taskId}`)

package/server/services/workshop/settings.ts

@@ -188,6 +188,27 @@ export interface DaqRuntimeSettings {
   }
   tsRetentionH: number
   frameRetentionH: number
+  /** 时序库连接与超时(生产调优) */
+  timescale: {
+    poolMax: number
+    statementTimeoutMs: number
+  }
+  /** 分层保留的聚合策略(1m/1h;历史查询跨保留期时自动使用) */
+  rollup: {
+    enabled: boolean
+    /** 调度间隔 */
+    intervalMs: number
+    /** 只聚合 now-lag 之前的闭合窗口 */
+    lagMs: number
+    /** 单窗口跨度(按 bucket 对齐) */
+    windowMs: number
+    /** 单轮最多窗口数 */
+    maxWindowsPerRun: number
+    /** 1 分钟聚合保留小时数 */
+    minuteRetentionH: number
+    /** 1 小时聚合保留小时数(0 = 永久) */
+    hourRetentionH: number
+  }
   alarmWebhookUrl: string
   alarmEscalateMinutes: number
 }
@@ -252,8 +273,21 @@ export function daqRuntimeSettings(): DaqRuntimeSettings {
       qos: Number(get('mqtt.qos', 0)),
       rejectUnauthorized: Boolean(get('mqtt.rejectUnauthorized', true)),
     },
-    tsRetentionH: Number(get('tsRetentionH', 168)),
+    tsRetentionH: Number(get('tsRetentionH', 720)),
     frameRetentionH: Number(get('frameRetentionH', 720)),
+    timescale: {
+      poolMax: Number(get('timescale.poolMax', 8)),
+      statementTimeoutMs: Number(get('timescale.statementTimeoutMs', 30_000)),
+    },
+    rollup: {
+      enabled: Boolean(get('rollup.enabled', true)),
+      intervalMs: Number(get('rollup.intervalMs', 600_000)),
+      lagMs: Number(get('rollup.lagMs', 300_000)),
+      windowMs: Number(get('rollup.windowMs', 3_600_000)),
+      maxWindowsPerRun: Number(get('rollup.maxWindowsPerRun', 24)),
+      minuteRetentionH: Number(get('rollup.minuteRetentionH', 8760)),
+      hourRetentionH: Number(get('rollup.hourRetentionH', 0)),
+    },
     alarmWebhookUrl: String(get('alarmWebhookUrl', '')),
     alarmEscalateMinutes: Number(get('alarmEscalateMinutes', 15)),
     sampling: {

package/server/services/workshop/types/task.ts

@@ -46,6 +46,8 @@ export interface WorkspaceTask {
   /** 终态/关闭原因与持久化 deadline */
   closeReason?: string
   deadlineAt?: string
+  /** 显式替代关系:本任务(FAILED/CANCELED 分支)被替代任务覆盖,不再阻塞父任务收口 */
+  supersededByTaskId?: string
   /** 执行交接代次(§5.1;每次新分配/重分配 +1,用于拒绝旧 worker 迟到事件) */
   assignmentGeneration?: number
   /** 当前执行租约 id / 持有者 / 起止时间(§2.1) */

package/server/utils/asset-auth.ts

@@ -0,0 +1,15 @@
+/**
+ * 资产类管理面守卫(2026-10-30 安全审计 P2-6)。
+ *
+ * 设备孪生(control/patch/delete)与 3D 模型上传此前只要求"已登录",
+ * 任何 `user` 角色都能操控/删除平台设备、往 public/ 上传文件。
+ * 这些是场景/资产的管理动作,收口到 editor 及以上(admin 越权放行)。
+ */
+import { AppError } from './errors'
+
+export interface AssetActor { id: string, role: string }
+
+export function assertAssetManager(user: AssetActor, what: string): void {
+  if (user.role === 'admin' || user.role === 'editor') return
+  throw new AppError(403, 'FORBIDDEN', `${what}需要编辑者(editor)或管理员(admin)权限`)
+}

package/server/utils/request-ip.ts

@@ -0,0 +1,29 @@
+/**
+ * 客户端 IP 解析(限流/登录锁定/审计的唯一取数点)。
+ *
+ * X-Forwarded-For 是**客户端可伪造**的请求头。只有部署在可信反向代理之后、
+ * 且反代已改写该头时才可信;直连部署若采信它,限流桶 / 404 封锁 / 登录失败锁定
+ * 全部可按伪造 IP 绕过(密码可无限暴破,也可反过来伪造受害者 IP 做锁定 DoS)。
+ *
+ * 因此:仅当 AW_TRUST_PROXY=1 时才采信 XFF,否则一律取 socket 地址。
+ * 不在本函数内自行解析 XFF 链——交给反代正确配置(h3 的 xForwardedFor 选项取首跳)。
+ */
+import { getRequestIP, type H3Event } from 'h3'
+
+const TRUST_PROXY_ENV = 'AW_TRUST_PROXY'
+
+/** 是否采信 X-Forwarded-For(每次调用读取,便于测试与热配置) */
+export function trustProxyEnabled(): boolean {
+  return process.env[TRUST_PROXY_ENV] === '1'
+}
+
+/** 真实客户端 IP;无法确定时返回 'local'。 */
+export function clientIp(event: H3Event): string {
+  try {
+    return (trustProxyEnabled() ? getRequestIP(event, { xForwardedFor: true }) : getRequestIP(event)) ?? 'local'
+  }
+  catch {
+    // event 形状不完整(单测/内部调用):退化为 local,不阻塞请求
+    return 'local'
+  }
+}

package/server/utils/response.ts

@@ -31,12 +31,9 @@ export function defineApiHandler<T>(handler: (event: H3Event) => Promise<T> | T)
         setResponseStatus(event, error.status)
         return { code: error.code, message: error.message, data: null }
       }
-      // 兜底:服务层抛出的裸 Error 若自带数字 status(历史约定),按其映射而非一律 500
-      const legacyStatus = (error as unknown as { status?: unknown }).status
-      if (typeof legacyStatus === 'number' && legacyStatus >= 400 && legacyStatus < 600) {
-        setResponseStatus(event, legacyStatus)
-        return { code: legacyStatus === 404 ? 'NOT_FOUND' : 'REQUEST_ERROR', message: (error as Error).message, data: null }
-      }
+      // 历史约定(裸 Error 自带数字 status)已全部迁移到 AppError(2026-10-30 P2-8):
+      // 该分支会把任意库错误的 message(可能含内部路径/SQL)直通前端,故删除。
+      // 现在只有 AppError 显式声明可对外消息;其余一律落到下面的 500 笼统文案。
       if (error instanceof H3Error) {
         // zValidator 抛出的 AppError 会被 h3 包装为 H3Error，此处还原精确信息
         const inner = error.data instanceof AppError ? error.data : null