agentworkshop 0.7.54 → 0.7.59

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

@@ -13,8 +13,8 @@ import { setHybridChannelProfile } from '../../aml/twin/channel-profile'
 import { defaultInjectionScene } from '../../aml/twin/physics-runtime'
 import { getChannelPluginsRepo } from '../../db/channel-plugins.repo'
 
-/** 携带「知识库集成」选项的模板:实例化时可显式启停 rag-bridge(开 → 注入 KB 作业段提示词) */
-export const KNOWLEDGE_BASE_TEMPLATE_IDS = new Set(['chtpl-aml-optimization-default', 'chtpl-generic-optimize-default'])
+/** 携带「知识库集成」选项的模板:实例化时可显式启停 rag-bridge(开 → 注入 KB 作业段提示词);产线 Co-Pilot 两观察面频道(经验/诊断)的经验与诊断沉淀均以 KB 为唯一持久层,必入本名单 */
+export const KNOWLEDGE_BASE_TEMPLATE_IDS = new Set(['chtpl-aml-optimization-default', 'chtpl-generic-optimize-default', 'chtpl-exp-miner-default', 'chtpl-line-doctor-default'])
 
 /** 知识库集成开启时追加到频道场景提示词的作业段(教全员:先检索、后行动、再沉淀;知识调优工程师为主消费者) */
 export const KNOWLEDGE_BASE_PROMPT_SECTION = `
@@ -192,6 +192,25 @@ export abstract class ManagerChannelTemplates extends ManagerTeams {
         createdBy: user.id,
       }))
     }
+    // 产线 Co-Pilot 观察面模板(2026-10-01 计划 §5.2/§5.3):经验工程师 / 诊断工程师 —— 零写只读档位。
+    // 档位落频道 profile(工具面由 host-tool-bridge/catalog 按档位白名单装配,物理零写);
+    // controlPolicy 强制 recommendation_only(观察面只建议不下发,P2 引入下发族时再放开)。
+    const expMinerProfile = options?.toolProfile === 'exp-miner' || tpl.id === 'chtpl-exp-miner-default'
+    const lineDoctorProfile = options?.toolProfile === 'line-doctor' || tpl.id === 'chtpl-line-doctor-default'
+    if (expMinerProfile || lineDoctorProfile) {
+      await Promise.resolve(setHybridChannelProfile({
+        channelId: created.channelId,
+        profile: expMinerProfile ? 'exp-miner' : 'line-doctor',
+        capability: { observer: true, knowledgeBase: true, phase: expMinerProfile ? 'experience_mining' : 'diagnosis' },
+        objective: options?.objective ?? {},
+        controlPolicy: 'recommendation_only',
+        providerId: options?.providerId,
+        providerVersion: options?.providerVersion,
+        providerHash: options?.providerHash,
+        scenePackId: options?.scenePackId,
+        createdBy: user.id,
+      }))
+    }
     return { channelId: created.channelId, workspace: created.workspace, agentCount, leadAgentId: created.leadAgentId, agents }
   }
 

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

@@ -13,7 +13,8 @@ import { Mailbox } from '../mailbox'
 import { SchedulerLoop } from '../scheduler-loop'
 import { buildMessage, instanceToAgentInfo, log, parseChannelLlm, rowToChannelMail, runtimeKey } from './helpers'
 import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
-import { harnessContinuityEnabled, workshopSettings } from '../../settings'
+import { harnessContinuityEnabled, rootQueueEnabled, workshopSettings } from '../../settings'
+import { TERMINAL_TASK_STATES, type TaskState } from '../../types/task'
 import { composeChannelSystemPrompt } from '../../aml/twin/prompt-composer'
 
 export abstract class ManagerRuntimeWiring extends ManagerBus {
@@ -265,6 +266,16 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
     if (!runtime) return
     if (runtime.getState() !== 'idle') return
     if (this.deps.repos.messages.listPendingByChannelAgent(channelId, agentId).length > 0) return
+    // 生产化(2026-10-09):挂起中的 HITL 审批卡视为活跃 —— 真人审批常超空闲宽限
+    // (~120s),而 stopAndDetach → runtime.stop() → cancelAllForAgent 会把卡收敛为
+    // 「回合已被中止」的拒绝(误杀人工裁决,hold 模式也拦不住这条路径)。动态 import
+    // 取审批单例,避免与 tool-approvals → platform-notice → manager 的静态环。
+    // 删除实例/频道仍走 stopAndDetach 直达(管理动作,保持 fail-closed 收敛语义)。
+    try {
+      const { getToolApprovals } = await import('../../agents/tool-approvals')
+      if (getToolApprovals().listPending(agentId).length > 0) return
+    }
+    catch { /* 审批面未装配(测试/降级)→ 按原语义放行 */ }
     // §6.1 Runtime 卸载闸门(五条件)。§11 harness_continuity_enabled=false 时退回
     // 旧行为(只看 runtime idle),仅用于异常回滚 —— 默认必须走完整闸门。
     if (harnessContinuityEnabled()) {
@@ -320,6 +331,9 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
           idleSince.delete(key)
         }
       }
+      void this.rescueStaleRoots().catch((err) => {
+        log.error(`[AgentChannelManager] D1 兜底扫异常(下轮继续):`, err)
+      })
     }, intervalMs)
     return () => {
       if (this.idleSweeperTimer) {
@@ -328,4 +342,85 @@ export abstract class ManagerRuntimeWiring extends ManagerBus {
       }
     }
   }
+
+  /**
+   * D1 兜底(2026-10-06):lead 根任务的入场依赖 omp 监督回合;会话握手抖动/自停/卸载时
+   * 队列根无限滞留 SUBMITTED(实测两例,activate+immediate 消息 nudge 即愈 —— 证明
+   * 「lead 领到消息的回合」是稳健入场路径)。把人工救援固化为管理层周期扫:
+   * 无活跃根 + 最老排队根滞留 >90s → ensureChannelActive(幂等复活 lead 运行时与
+   * 调度循环)+ immediate 领取提示唤醒消费循环。健康频道入场在秒级完成,不会触发;
+   * 同一根 10 分钟冷却,防消息刷屏。
+   */
+  protected rescueSeen = new Map<string, number>()
+
+  protected async rescueStaleRoots(): Promise<void> {
+    if (!rootQueueEnabled()) return
+    const now = Date.now()
+    const RESCUE_STALE_MS = 90_000
+    const RESCUE_COOLDOWN_MS = 10 * 60_000
+    if (this.rescueSeen.size > 500) this.rescueSeen.clear()
+    for (const channel of this.deps.repos.channels.list()) {
+      if (channel.enabled !== 1 || !channel.leadAgentId) continue
+      let roots
+      try {
+        roots = this.deps.repos.tasks.listRoots(channel.id)
+      }
+      catch { continue }
+      // 入场资格 = 队头**开放**根本身是滞留的 SUBMITTED lead 根:rootQueue 语义里「队头
+      // 非终态根即 activeRoot」,因此不能用 activeRootOf 判空(它对卡死场景恒真,救援会
+      // 成死代码);必须先滤掉终态根(FAILED 旧根占着 seq=1 会挡住重开的 seq=2 根,实测)。
+      // 队头若是 WORKING/WAITING 说明有根在跑,绝不插入。
+      const head = roots.find(r => !TERMINAL_TASK_STATES[r.state as TaskState])
+      if (!head || head.state !== 'SUBMITTED' || head.assigneeId !== channel.leadAgentId) continue
+      if (now - Date.parse(head.createdAt) < RESCUE_STALE_MS) continue
+      const last = this.rescueSeen.get(head.id) ?? 0
+      if (now - last < RESCUE_COOLDOWN_MS) continue
+      this.rescueSeen.set(head.id, now)
+      log.warn(`[AgentChannelManager] D1 兜底:channel ${channel.id.slice(0, 8)} 排队根 ${head.id.slice(0, 8)}「${String(head.title).slice(0, 40)}」滞留 SUBMITTED —— 复活 lead 并投递 assign 领取消息`)
+      try {
+        // 一律卸载后重组:restore 恢复的运行时可能 state 显示 idle 但消费循环从未启动
+        // (自停态恢复不 start,实测消息表 pending 永滞而 omp RPC 仍应答 compact)——
+        // 与其猜状态,不如给一次干净的 stop→dispose→重新 wire→start()。
+        // 救援路径本身罕见(90s 滞留 + 10min 冷却),omp 冷启动 30~90s 代价可接受。
+        if (this.runtimeOf(channel.id, channel.leadAgentId)) {
+          log.warn(`[AgentChannelManager] D1 兜底:卸载既有 lead 运行时后重组(消费循环可疑失活)`)
+          await this.unloadAgent(channel.id, channel.leadAgentId)
+        }
+        this.ensureChannelActive(channel.id)
+        // 入场即刷新执行预算(deadline 语义=执行预算,预算从入场起算):滞留根的旧预算
+        // 早已耗尽,不刷新则 tick 的过期收口会在 WORKING 后立即处决它。
+        try {
+          const engine = this.getTaskEngine() as { refreshDeadline?: (id: string, iso: string) => unknown }
+          const budgetMs = Math.max(10_000, Number(workshopSettings().root_timeout_ms ?? 900_000))
+          engine.refreshDeadline?.(head.id, new Date(Date.now() + budgetMs).toISOString())
+        }
+        catch { /* 极简引擎替身缺方法:跳过,入场后由既有预算语义接管 */ }
+      }
+      catch (err) {
+        log.warn(`[AgentChannelManager] D1 兜底复活失败(下轮重试): ${err instanceof Error ? err.message : String(err)}`)
+        continue
+      }
+      // 正规 assign 消息(与人类直发 worker 同构):FIFO 准入已满足(无活跃根+最老 seq),
+      // assign 语义让 lead 消息路径自动 SUBMITTED→WORKING(补 RUNNING 中间态可见性),
+      // 回合载荷=任务简报,走消息消费循环的稳健入场路径。
+      const brief = [head.title, head.description ?? ''].filter(Boolean).join('\n')
+      const rescueMessage = buildMessage(
+        channel.id,
+        'ROLE_USER',
+        [{ text: brief || head.title }],
+        {
+          'x-aw-target-agent': channel.leadAgentId,
+          'x-aw-msg-priority': 'immediate',
+          'x-aw-task-kind': 'assign',
+          'x-aw-task-id': head.id,
+          'x-aw-from-label': '调度兜底',
+        },
+      )
+      rescueMessage.taskId = head.id
+      const delivered = this.route(channel.id, rescueMessage)
+      if (!delivered.includes(channel.leadAgentId)) {
+        log.warn(`[AgentChannelManager] D1 兜底 assign 消息投递失败(下轮重试): root=${head.id.slice(0, 8)}`)
+      }
+    }
+  }
 }

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

@@ -19,7 +19,10 @@ import { TEAM_AGENT_ID } from '../../db/memory.repo'
 import { TERMINAL_TASK_STATES } from '../../types/task'
 import { TaskEngine as TaskEngineImpl } from '../task-engine'
 import { createEnvEmbeddingProvider } from '../embedding-provider'
-import { log } from './helpers'
+import { log, buildMessage } from './helpers'
+
+import { rowToMessage } from '../mailbox'
+import { platformNoticeKey, newPlatformNoticeId, setPlatformNoticeSink, type PlatformNotice, type PlatformNoticeSink } from '../platform-notice'
 import { memorySettings, retentionSettings, channelMemoryDigestEnabled } from '../../settings'
 import { parseJson } from '../../db/database'
 
@@ -103,6 +106,22 @@ export abstract class ManagerState extends ManagerContracts {
    * 该标记让 attachScheduler 在停机后拒绝挂载(生产无影响:停机后即进程退出)。
    */
   protected shutdownStarted = false
+  /** 平台通告已消费键(tool:jobId / hitl:…;先到先得去重 + 有界化) */
+  private readonly platformNoticeSeen = new Set<string>()
+  /** 平台通告去重表容量上限(完成即消费的短命键;超出裁最旧) */
+  private static readonly PLATFORM_NOTICE_SEEN_CAP = 2000
+  /** 接线后的 sink 实现(插件通告服务 deliverPlatformNotice/claimPlatformNotice 委托目标) */
+  private platformNoticeSinkImpl: PlatformNoticeSink | null = null
+
+  /** 插件通告面(ctx.services.get('notify').deliver):委托全局 sink 实现 */
+  deliverPlatformNotice(notice: PlatformNotice): boolean {
+    return this.platformNoticeSinkImpl?.deliver(notice) ?? false
+  }
+
+  /** 插件通告面(ctx.services.get('notify').claim):委托全局 sink 实现 */
+  claimPlatformNotice(tool: string, jobId: string): boolean {
+    return this.platformNoticeSinkImpl?.claim(tool, jobId) ?? false
+  }
 
   /** 依赖集(repos/implFactory/db)。
    *  API 作业面(ws/agent-tools/a2a card/…)需要直接读 repo —— 原先只能靠
@@ -111,6 +130,7 @@ export abstract class ManagerState extends ManagerContracts {
    *  既去掉断言又保持封装语义(依赖注入本身就是本类的构造契约)。 */
   constructor(readonly deps: ManagerDeps) {
     super()
+    this.wirePlatformNoticeSink()
     // 记忆衰减清理定时器(失败只记日志,绝不抛出;unref 不阻进程退出;非法/非正 env 回退默认)
     this.memoryTimer = setInterval(() => {
       try {
@@ -142,6 +162,91 @@ export abstract class ManagerState extends ManagerContracts {
     this.outboxTimer.unref?.()
   }
 
+  /**
+   * 平台通告面接线(platform-notice 全局 sink 的真实实现)。
+   *
+   * 投递 = 直接落 messages 表(pending):信箱关闭/Agent 未装配也不丢,下次装配
+   * 按 FIFO 消费;已装配的 Agent 即时 wakeMailbox(空闲则立即起回合处理回执)。
+   * 直接落库而非 mailbox.enqueue,是因为 stop() 后 mailbox.closed 会静默丢弃——
+   * 恰恰是"回合已死"的孤儿场景最需要这条补送。
+   * 去重:tool-result 按 tool:jobId 先到先得(status 工具轮询认领后不再补发);
+   * hitl-note 低频由调用方保证。时间线可见性与 route 的 onRouted 同构(notifyMessage)。
+   */
+  protected wirePlatformNoticeSink(): void {
+    const sink: PlatformNoticeSink = {
+      claim: (tool, jobId) => {
+        const key = `${tool}:${jobId}`
+        if (this.platformNoticeSeen.has(key)) return false
+        this.platformNoticeSeen.add(key)
+        this.prunePlatformNoticeSeen()
+        return true
+      },
+      deliver: (notice) => {
+        const key = platformNoticeKey(notice)
+        if (this.platformNoticeSeen.has(key)) return false
+        const channelId = notice.channelId
+          ?? this.deps.repos.channelAgents.findById(notice.agentId)?.channelId
+          ?? null
+        if (!channelId) {
+          // 成员已删除/无归属 channel:无处投递,标记已消费(成员行不会复活)
+          this.platformNoticeSeen.add(key)
+          this.prunePlatformNoticeSeen()
+          return false
+        }
+        const member = this.deps.repos.channelAgents.findByChannelAgent(channelId, notice.agentId)
+        if (!member || member.enabled !== 1) {
+          this.platformNoticeSeen.add(key)
+          this.prunePlatformNoticeSeen()
+          return false
+        }
+        const header = notice.kind === 'tool-result'
+          ? `[异步回执] ${notice.title}(tool=${notice.tool}, job=${notice.jobId}, 结果=${notice.ok ? '完成' : '失败'})`
+          : `[平台通告] ${notice.title}`
+        const message = buildMessage(channelId, 'ROLE_USER', [{ text: `${header}\n${notice.summary}` }], {
+          'x-aw-target-agent': notice.agentId,
+          'x-aw-from-label': '平台',
+          'x-aw-msg-kind': notice.kind,
+          ...(notice.kind === 'tool-result'
+            ? { 'x-aw-tool': notice.tool, 'x-aw-job-id': notice.jobId, ...(notice.taskId ? { 'x-aw-related-task': notice.taskId } : {}) }
+            : {}),
+        })
+        // 落库即投递:绕过 mailbox 的 closed 闸门(stop 后的孤儿补送必须能落),
+        // 消费循环重启后按 pending 认领;id 用独立前缀,与业务消息可区分
+        const row = this.deps.repos.messages.create({
+          id: newPlatformNoticeId(),
+          channelId,
+          taskId: null,
+          fromAgentId: null,
+          toAgentId: notice.agentId,
+          role: 'ROLE_USER',
+          parts: message.parts,
+          metadata: message.metadata,
+        })
+        this.platformNoticeSeen.add(key)
+        this.prunePlatformNoticeSeen()
+        // 时间线可见(与 route 成功后的 onRouted 同构);已装配的 Agent 即时唤醒
+        try {
+          this.buses.get(channelId)?.notifyMessage(rowToMessage(row))
+        }
+        catch { /* 广播失败不影响投递 */ }
+        const cr = this.channels.get(channelId)
+        cr?.getAgents().find(a => a.agentId === notice.agentId)?.wakeMailbox()
+        return true
+      },
+    }
+    this.platformNoticeSinkImpl = sink
+    setPlatformNoticeSink(sink)
+  }
+
+  /** 通告去重表有界化(长跑进程内存有界;裁最旧) */
+  private prunePlatformNoticeSeen(): void {
+    if (this.platformNoticeSeen.size <= ManagerState.PLATFORM_NOTICE_SEEN_CAP) return
+    for (const k of this.platformNoticeSeen) {
+      this.platformNoticeSeen.delete(k)
+      if (this.platformNoticeSeen.size <= ManagerState.PLATFORM_NOTICE_SEEN_CAP) break
+    }
+  }
+
   /**
    * 群聊层周期性有界化(与记忆维护同一定时器,零额外 timer):
    *  ① outbox 补偿:把滞留的 pending 行重新发布(发布阶段崩溃/漏标时的事实源收敛);

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

@@ -4,12 +4,13 @@
  */
 import { ManagerChannelTemplates } from './channel-templates'
 import type { A2AArtifact, Part } from '../../types/a2a'
-import type { AgentStatusView, AgentTaskQueueView, WorkspaceTask } from '../../types/task'
+import { TERMINAL_TASK_STATES } from '../../types/task'
+import type { AgentStatusView, AgentTaskQueueView, WorkspaceTask, TaskState } from '../../types/task'
 import type { ExecutionMode } from '../../agents/agent-interface'
 import type { ModeConfig } from '../execution-mode'
 import type { TaskPatch } from '../../db/task.repo'
 import { AppError } from '../../../../utils/errors'
-import { TERMINAL_TASK_STATES } from '../../types/task'
+
 import { assertHarnessUsable } from '../../agents/harness-availability'
 import { buildMessage, rowToTask } from './helpers'
 import { encodeTaskMode, isGoalSummaryArtifact } from '../execution-mode'
@@ -69,6 +70,15 @@ export abstract class ManagerTasks extends ManagerChannelTemplates {
     const deadlineAt = input.mode
       ? undefined
       : new Date(Date.now() + Math.max(10_000, Number(workshopSettings().root_timeout_ms ?? 900_000))).toISOString()
+    // 活动根判重(2026-10-04 场景C实录:同一工作包被重复派成多个根,靠 prompt「减噪约定」
+    // 收口 —— 机制缺位)。规则:同频道+同收件人存在**非终态**根且归一化标题一致 → 复用该根,
+    // 不再造重复行(终态任务不参与判重,保留「同标题并排重跑」的既有语义)。
+    const normTitle = (s: string) => s.replace(/\s+/g, '')
+    const dupRoot = this.deps.repos.tasks.listRoots(input.channelId).find(r =>
+      !TERMINAL_TASK_STATES[r.state as TaskState]
+      && r.assigneeId === assigneeId
+      && normTitle(r.title) === normTitle(input.title))
+    if (dupRoot) return rowToTask(dupRoot)
     let task = this.getTaskEngine().create({
       channelId: input.channelId,
       creatorId: '',
@@ -103,7 +113,16 @@ export abstract class ManagerTasks extends ManagerChannelTemplates {
       'x-aw-task-id': task.id,
     }
     if (input.fromLabel) messageMetadata['x-aw-from-label'] = input.fromLabel
-    const message = buildMessage(input.channelId, 'ROLE_USER', input.parts ?? [], messageMetadata)
+    // 简报兜底:人类直派常只填 title/description(不带 parts)——assign 消息若只有空
+    // parts,worker 的回合提示词里任务正文为空,LLM worker 只能对着任务名瞎猜
+    // (实测 codex worker 完成任务却答"未提供任务目标")。
+    const brief = [input.title, input.description ?? ''].filter(Boolean).join('\n')
+    const message = buildMessage(
+      input.channelId,
+      'ROLE_USER',
+      [...(input.parts ?? []), ...(brief && !(input.parts ?? []).length ? [{ text: brief }] : [])],
+      messageMetadata,
+    )
     message.taskId = task.id
     const delivered = this.route(input.channelId, message)
     if (!delivered.includes(assigneeId)) {
@@ -208,7 +227,13 @@ export abstract class ManagerTasks extends ManagerChannelTemplates {
         parts: input.parts,
       })
       task = this.getTaskEngine().transition(task.id, 'ASSIGNED', callerAgentId)
-      const message = buildMessage(channelId, 'ROLE_USER', input.parts ?? [], {
+      // 简报兜底(与 submitChannelTask 直派同口径):lead 派发若只给 title/description
+      // 而无 parts,assign 消息正文为空,worker 回合失去任务简报。
+      const childBrief = [input.title, input.description ?? ''].filter(Boolean).join('\n')
+      const message = buildMessage(channelId, 'ROLE_USER', [
+        ...(input.parts ?? []),
+        ...(childBrief && !(input.parts ?? []).length ? [{ text: childBrief }] : []),
+      ], {
         'x-aw-task-kind': 'assign',
         'x-aw-task-id': task.id,
         'x-aw-from-agent': callerAgentId,
@@ -515,4 +540,42 @@ export abstract class ManagerTasks extends ManagerChannelTemplates {
     this.wakeAgent(channelId, target.id)
     return updated
   }
+
+  /**
+   * 重开终态根任务(2026-10-05 机制补位):创建承接新根,替代"改标题重派"。
+   * - 仅根任务、仅 FAILED/CANCELED(COMPLETED 拒绝);description 头部 [reopen:<id8>] 标记溯源;
+   * - 同源在途重开单已存在(非终态根描述含同标记)→ 409 防多根再生;
+   * - 走 submitChannelTask:自动获得 lead 校验/判重/FIFO 排队/新预算(reopen≠重试,预算全新)。
+   */
+  async reopenTask(input: {
+    channelId: string
+    taskId: string
+    title?: string
+    description?: string
+    fromLabel?: string
+  }): Promise<WorkspaceTask> {
+    const origin = this.deps.repos.tasks.findById(input.taskId)
+    if (!origin || origin.channelId !== input.channelId) {
+      throw new AppError(404, 'NOT_FOUND', `任务不存在: ${input.taskId}`)
+    }
+    if (origin.parentId) throw new AppError(400, 'INVALID_STATE', '仅根任务可 reopen(子任务请重派其根)')
+    if (origin.state !== 'FAILED' && origin.state !== 'CANCELED') {
+      throw new AppError(409, 'INVALID_STATE', `任务状态 ${origin.state} 不可 reopen(仅 FAILED/CANCELED)`)
+    }
+    const marker = `[reopen:${origin.id.slice(0, 8)}]`
+    const inFlight = this.deps.repos.tasks.listRoots(input.channelId).find(r =>
+      !TERMINAL_TASK_STATES[r.state as TaskState]
+      && (r.description ?? '').includes(marker))
+    if (inFlight) {
+      throw new AppError(409, 'ROOT_REOPEN_IN_FLIGHT', `该任务已有在途重开单(根 ${inFlight.id.slice(0, 8)}),防多根再生;等待其终态后再试`)
+    }
+    const description = `${marker} ${input.description ?? origin.description ?? ''}`.trim()
+    return this.submitChannelTask({
+      channelId: input.channelId,
+      title: input.title ?? origin.title,
+      description,
+      assigneeId: origin.assigneeId || undefined,
+      fromLabel: input.fromLabel ?? 'reopen',
+    })
+  }
 }

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

@@ -83,7 +83,7 @@ export abstract class ManagerWorkspace extends ManagerRuntimeObserve {
   protected async submitLeadRootTask(
     channelId: string,
     callerAgentId: string,
-    input: { title: string, description?: string, parts?: Part[], sourceChatMessageId?: string, sourceChatDeliveryId?: string },
+    input: { title: string, description?: string, parts?: Part[], sourceChatMessageId?: string, sourceChatDeliveryId?: string, budgetMinutes?: number },
   ): Promise<WorkspaceTask> {
     const caller = this.requireMember(channelId, callerAgentId)
     if (caller.role !== 'lead') {
@@ -91,9 +91,15 @@ export abstract class ManagerWorkspace extends ManagerRuntimeObserve {
     }
     const title = String(input.title ?? '').trim()
     if (!title) throw new AppError(400, 'BAD_REQUEST', 'submit_task 需要非空 title')
+    // 预算:lead 可显式声明 budgetMinutes —— 长工业链路(如 8 步巡检)在 15min 默认预算下
+    // 会被预算处决(实测 2026-10-06);未声明沿用 root_timeout_ms。上限 6h 防滥用。
+    const declaredMinutes = Number(input.budgetMinutes)
+    const budgetMs = Number.isFinite(declaredMinutes) && declaredMinutes > 0
+      ? Math.min(declaredMinutes * 60_000, 6 * 3_600_000)
+      : Math.max(10_000, Number(workshopSettings().root_timeout_ms ?? 900_000))
     const deadlineAt = /^\[mode:(goal|loop|pipeline)\]/.test(input.description ?? '')
       ? undefined
-      : new Date(Date.now() + Math.max(10_000, Number(workshopSettings().root_timeout_ms ?? 900_000))).toISOString()
+      : new Date(Date.now() + Math.max(10_000, budgetMs)).toISOString()
 
     // sourceChatMessageId 是 canonical root identity。createOrGetRoot 在 repo 层以
     // partial unique index 做最终并发闸门；即使 Lead 改标题或重复 submit，仍返回原 root。

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

@@ -192,7 +192,13 @@ export abstract class AgentMemoryRecall extends AgentMemoryState {
   async recallRows(query: string, opts: { scope?: MemoryScope, limit?: number, relatedTaskIds?: string[] } = {}): Promise<MemorySnippet[]> {
     const scope = opts.scope ?? 'auto'
     const limit = Math.min(Math.max(opts.limit ?? 5, 1), 20)
-    const scored = (await this.rank(query, scope, { relatedTaskIds: opts.relatedTaskIds })).slice(0, limit)
+    // 召回度量(2026-10-05 记忆治理最小版):hit/miss 计数 —— 72% 记忆从未被召回的
+    // 问题先变成可观测数据,再决定是否值得做自动合并。
+    const stats = recallStatsOf()
+    const scoredAll = await this.rank(query, scope, { relatedTaskIds: opts.relatedTaskIds })
+    if (scoredAll.length > 0) stats.hits++
+    else stats.misses++
+    const scored = scoredAll.slice(0, limit)
     for (const s of scored) this.repo.touch(s.row.id)
     return scored.map((s) => {
       const shared = s.row.agentId === TEAM_AGENT_ID
@@ -214,3 +220,16 @@ export abstract class AgentMemoryRecall extends AgentMemoryState {
     })
   }
 }
+
+const gRecall = globalThis as typeof globalThis & { __awRecallStats?: { hits: number, misses: number } }
+function recallStatsOf(): { hits: number, misses: number } {
+  gRecall.__awRecallStats ??= { hits: 0, misses: 0 }
+  return gRecall.__awRecallStats
+}
+
+/** 召回度量(进程内;restart 归零 —— 趋势观测用,不承诺持久) */
+export function memoryRecallStats(): { hits: number, misses: number, hitRate: string } {
+  const s = recallStatsOf()
+  const total = s.hits + s.misses
+  return { hits: s.hits, misses: s.misses, hitRate: total ? `${Math.round((s.hits / total) * 100)}%` : 'n/a' }
+}