agentworkshop 0.7.65 → 0.7.70

package/server/services/workshop/mes/mes-datasets.ts

@@ -10,10 +10,10 @@
  * 取既有 DcwWriteDriver 的可选 fetchHistory 原语(结构化本地声明,签名与驱动面约定一致)。
  */
 import { createHash, randomUUID } from 'node:crypto'
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeSync } from 'node:fs'
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync, writeSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 import type { DatabaseSync } from 'node:sqlite'
-import type { DcwWriteDriver } from '../dcw/drivers/shared'
+import type { DcwFieldDef, DcwWriteDriver } from '../dcw/drivers/shared'
 import { resolveDcwDriver } from '../dcw/drivers'
 import { AppError, ErrorCodes } from '../../../utils/errors'
 
@@ -118,6 +118,8 @@ export interface MesDatasetRow {
   rows: number
   sha256: string
   filePath: string
+  /** 数据字典/物理含义清单(与 CSV 同目录,便于离线分析直接读) */
+  manifestPath: string
   /** running(取数中) | ready | failed */
   status: string
   error: string
@@ -153,6 +155,7 @@ function toDatasetRow(r: Record<string, unknown>, bootedAt: string): MesDatasetR
     rows: Number(r.rows ?? 0),
     sha256: String(r.sha256 ?? ''),
     filePath: String(r.filePath ?? ''),
+    manifestPath: String(r.filePath ?? '').replace(/\.csv$/i, '.manifest.json'),
     status: String(r.status ?? 'ready'),
     error: String(r.error ?? ''),
     createdBy: String(r.createdBy ?? ''),
@@ -204,9 +207,9 @@ export interface MesDatasetStatsView {
 export interface MesDatasetRowsView { offset: number, total: number, rows: string[][] }
 
 export type MesDatasetRead
-  = { meta: MesDatasetRow, mode: 'head', head: MesDatasetHeadView }
-    | { meta: MesDatasetRow, mode: 'stats', stats: MesDatasetStatsView }
-    | { meta: MesDatasetRow, mode: 'rows', rowsView: MesDatasetRowsView }
+  = { meta: MesDatasetRow, mode: 'head', head: MesDatasetHeadView, dictionary: DcwFieldDef[] }
+    | { meta: MesDatasetRow, mode: 'stats', stats: MesDatasetStatsView, dictionary: DcwFieldDef[] }
+    | { meta: MesDatasetRow, mode: 'rows', rowsView: MesDatasetRowsView, dictionary: DcwFieldDef[] }
 
 // ============================================================
 // 仓储工厂(全 prepared 占位符绑定,零字符串拼接)
@@ -222,6 +225,19 @@ export interface MesCreateFetchJobInput {
   nodeName?: string
   /** 节点驱动配置(取数时透传给驱动) */
   driverConfig?: Record<string, unknown>
+  /** 已知字段字典(响应缓存/节点静态配置;驱动回包里的字典优先) */
+  dictionary?: DcwFieldDef[]
+  /** 节点物理元数据(写入 manifest,离线分析可读) */
+  nodeMeta?: {
+    unit?: string
+    min?: number
+    max?: number
+    description?: string
+    semantics?: string
+    format?: string
+  }
+  /** 批次上下文(活动 LineRun;写入 manifest) */
+  context?: { lineId?: string, productId?: string, recipeId?: string, runId?: string }
 }
 
 export type MesDatasetStore = ReturnType<typeof createMesDatasetStore>
@@ -276,6 +292,22 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
     return join(datasetsDir, `${safe || 'unknown'}.csv`)
   }
 
+  function manifestPathOf(csvPath: string): string {
+    return csvPath.replace(/\.csv$/i, '.manifest.json')
+  }
+
+  /** 读数据集 manifest(不存在/损坏 → null;不击穿取数) */
+  function readManifest(meta: MesDatasetRow): Record<string, unknown> | null {
+    try {
+      if (!meta.manifestPath || !existsSync(meta.manifestPath)) return null
+      const parsed = JSON.parse(readFileSync(meta.manifestPath, 'utf8')) as unknown
+      return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : null
+    }
+    catch {
+      return null
+    }
+  }
+
   /** 取数执行体(进程内异步;写 CSV → sha256 → dataset=ready → job=done;异常 → 双 failed+error) */
   async function runFetchJob(jobId: string, datasetId: string, input: MesCreateFetchJobInput): Promise<void> {
     const filePath = csvPathOf(datasetId)
@@ -290,6 +322,8 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
     let dim = 0
     let dimDrift = 0
     let skipped = 0
+    let columns: string[] = []
+    let dictionary: DcwFieldDef[] = input.dictionary ?? []
     try {
       if (typeof driver.fetchHistory !== 'function') {
         throw new Error('mes-rest 驱动未提供 fetchHistory 原语(驱动实现缺失或未注册)')
@@ -297,6 +331,7 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
       fd = openSync(filePath, 'w')
       const writeHeader = (line: string): void => {
         writeAll(fd!, hash, `${line}\r\n`)
+        columns = line.split(',')
         headerWritten = true
       }
       const result = await driver.fetchHistory({
@@ -346,6 +381,7 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
         closeSync(fd)
         fd = null
       }
+      if (result?.dictionary && result.dictionary.length > 0) dictionary = result.dictionary
       // 驱动自报不完整 → ready 但 error 留截断备注(数据仍可用);完整 → error 清空
       const notes = [
         result && result.complete === false ? `truncated:驱动在 maxRows=${maxRows} 内未返回完整窗口` : '',
@@ -353,7 +389,45 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
         skipped > 0 ? `skipped:${skipped} 行不落盘` : '',
       ].filter(Boolean)
       const note = notes.join('; ')
-      finalizeDatasetReady.run(rows, hash.digest('hex'), note, datasetId)
+      const digest = hash.digest('hex')
+      // 数据字典/物理含义清单与 CSV 同目录:离线分析不必回读平台就能知道每列含义
+      const manifest = {
+        schema: 'aw.mes-dataset/1',
+        dataset_id: datasetId,
+        created_at: new Date().toISOString(),
+        node: {
+          id: input.nodeId,
+          name: input.nodeName ?? input.nodeId,
+          line_id: input.lineId ?? '',
+          unit: input.nodeMeta?.unit ?? '',
+          range: { min: input.nodeMeta?.min ?? null, max: input.nodeMeta?.max ?? null },
+          description: input.nodeMeta?.description ?? '',
+          semantics: input.nodeMeta?.semantics ?? '',
+          format: input.nodeMeta?.format ?? (wide ? 'vector' : 'scalar'),
+        },
+        context: input.context ?? {},
+        window: { from: input.fromIso ?? null, to: input.toIso ?? null },
+        data: {
+          file: filePath,
+          format: 'csv',
+          columns,
+          rows,
+          sha256: digest,
+          encoding: 'UTF-8',
+          vector: wide ? { dim, dimension_drift_rows: dimDrift } : undefined,
+        },
+        fields: dictionary,
+        notes: note,
+        usage: 'CSV 首行为列名:ts=样本时间(ISO),value=标量工程值, v0..vN=向量第 N 个点位。字段含义/单位/量程见 fields(向量点位用 points 描述每个下标);context 给出产线/产品/配方/批次归属。',
+      }
+      try {
+        writeFileSync(manifestPathOf(filePath), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8')
+      }
+      catch (mErr) {
+        // manifest 失败不否定数据可用性,但留下明确错误
+        console.error('[mes-datasets] manifest 写入失败:', mErr)
+      }
+      finalizeDatasetReady.run(rows, digest, note, datasetId)
       finalizeJobDone.run(rows, new Date().toISOString(), jobId)
     }
     catch (err) {
@@ -426,12 +500,15 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
       const columns = lines.length > 0 ? parseCsvLine(lines[0]!) : ['ts', 'value']
       const rows = lines.slice(1).map(l => parseCsvLine(l))
       const valueCol = Math.max(0, columns.indexOf('value') >= 0 ? columns.indexOf('value') : 1)
+      const manifest = readManifest(meta)
+      const dictionary = Array.isArray(manifest?.fields) ? manifest!.fields as DcwFieldDef[] : []
 
       if (mode === 'head') {
         return {
           meta,
           mode,
           head: { columns, totalRows: rows.length, preview: rows.slice(0, 5) },
+          dictionary,
         }
       }
       if (mode === 'stats') {
@@ -455,7 +532,7 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
         const stddev = n > 1
           ? Math.sqrt(vals.reduce((a, b) => a + (b - mean!) ** 2, 0) / (n - 1))
           : (n === 1 ? 0 : null)
-        return { meta, mode, stats: { count: n, min, max, mean, stddev, firstTs, lastTs } }
+        return { meta, mode, stats: { count: n, min, max, mean, stddev, firstTs, lastTs }, dictionary }
       }
       // rows:offset 起 20 行分页
       const off = Math.max(0, Math.round(offset) || 0)
@@ -463,6 +540,7 @@ export function createMesDatasetStore(db: DatabaseSync, datasetsDir: string, opt
         meta,
         mode,
         rowsView: { offset: off, total: rows.length, rows: rows.slice(off, off + 20) },
+        dictionary,
       }
     },
   }

package/server/services/workshop/ops/ops.ts

@@ -4,6 +4,7 @@
  * 附 audit() 兜底助手:审计写入失败永不击穿主链路。
  */
 import type { createApprovalHistoryRepo, createAlarmEventRepo, createAuditRepo, createApprovalRequestRepo } from '../db/ops.repo'
+import { normalizeAuditScope } from '../db/ops.repo'
 import { broadcastSceneEvent } from '../scene-events'
 
 export interface OpsRepos {
@@ -47,6 +48,8 @@ export interface OpsLogFrame {
   lineId: string
   productId: string
   recipeId: string
+  /** 显式域标识:line(产线日志)/ system(全局审计) */
+  scope: 'line' | 'system'
   /** 严重级(2026-10-08 ACK 鉴定):error 红 / warn 黄 / info 缺省 */
   level?: 'info' | 'warn' | 'error'
 }
@@ -55,24 +58,34 @@ export interface OpsLogFrame {
  * 全操作记录(统一入口):落 audit_log + 广播 ops.log 实时帧。
  * summary 人读摘要供实时事件直接渲染;结构化详情在 audit_log.detail_json。
  * 失败静默 —— 日志永不击穿业务主链路。
+ *
+ * 实时帧只广播**产线域**记录(lineId 非空):登录/用户管理/系统设置/备份等全局事件
+ * 仍进 audit_log(安全审计面 /api/workshop/audit 可查),但不得污染 /logs、/operations
+ * 的产线日志与实时轨。
  */
 export function recordOps(entry: Parameters<ReturnType<typeof createAuditRepo>['append']>[0]): void {
   try {
-    getOps()?.audit.append(entry)
+    const lineId = String(entry.lineId ?? '').trim()
+    // 显式域不变量:line 必须有产线锚点;缺锚点 fail-closed 降级 system,不得静默混入产线日志
+    const scope = normalizeAuditScope(lineId, entry.scope)
+    const normalized = { ...entry, lineId, scope }
+    getOps()?.audit.append(normalized)
+    if (scope !== 'line') return
     broadcastSceneEvent('ops.log', {
-      at: entry.at ?? new Date().toISOString(),
-      actor: entry.actor,
-      actorName: entry.actorName ?? '',
-      actorKind: entry.actorKind ?? 'user',
-      action: entry.action,
-      kind: entry.kind ?? '',
-      summary: entry.summary ?? entry.action,
-      targetKind: entry.targetKind ?? '',
-      targetId: entry.targetId ?? '',
-      lineId: entry.lineId ?? '',
-      productId: entry.productId ?? '',
-      recipeId: entry.recipeId ?? '',
-      ...(entry.level && entry.level !== 'info' ? { level: entry.level } : {}),
+      at: normalized.at ?? new Date().toISOString(),
+      actor: normalized.actor,
+      actorName: normalized.actorName ?? '',
+      actorKind: normalized.actorKind ?? 'user',
+      action: normalized.action,
+      kind: normalized.kind ?? '',
+      summary: normalized.summary ?? normalized.action,
+      targetKind: normalized.targetKind ?? '',
+      targetId: normalized.targetId ?? '',
+      lineId,
+      productId: normalized.productId ?? '',
+      recipeId: normalized.recipeId ?? '',
+      scope,
+      ...(normalized.level && normalized.level !== 'info' ? { level: normalized.level } : {}),
     } satisfies OpsLogFrame)
   }
   catch {

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

@@ -1,68 +1,77 @@
-/**
- * 插件运行时服务种子(ctx.* 懒绑定)
- * (由 server/services/workshop/plugins/host.mjs 按职责拆出;内容逐行原文搬运)
- */
-import { g } from './config.mjs'
-import { pluginManifest } from './api.mjs'
-
-export const servicesExt = (g.__awPluginServices ??= {
-  registry: new Map(),
-  /** 核心服务注册(name → 惰性 getter);宿主启动期 seed */
-  register(name, get) {
-    this.registry.set(String(name), get)
-  },
-  /** 插件供服务(自动加 `<plugin>.` 前缀;同前缀同名覆盖) */
-  provide(plugin, name, get) {
-    this.registry.set(`${plugin}.${String(name)}`, get)
-  },
-  names() {
-    return [...this.registry.keys()]
-  },
-  /** 取运行时服务对象(惰性求值并缓存;失败抛错由调用方兜底) */
-  async get(name) {
-    const get = this.registry.get(String(name))
-    if (!get) throw new Error(`未知运行时服务: ${name}(可用: ${this.names().join(', ')})`)
-    get._cache ??= get()
-    return await get._cache
-  },
-})
-
-/** 插件可获取的后端运行时对象(只读取数面;懒加载避免循环导入,失败即抛由插件兜底) */
-export async function seedRuntimeServices() {
-  if (servicesExt.registry.has('daq')) return
-  servicesExt.register('daq', async () => {
-    const storage = await import('@/server/services/workshop/daq/storage/index')
-    const nodes = await import('@/server/services/workshop/daq/daq-node.repo')
-    return {
-      query: q => storage.getTsdb().queryTagged(q),
-      nodes: () => nodes.getDaqNodeRepo().snapshot(),
-    }
-  })
-  servicesExt.register('lines', async () => {
-    const m = await import('@/server/services/workshop/dcw/dcw-line.repo')
-    const repo = m.getDcwLineRepo()
-    return { list: () => repo.all(), byId: id => repo.byId(id) }
-  })
-  servicesExt.register('channels', async () => {
-    const m = await import('@/server/plugins/workshop')
-    const mgr = m.getWorkshopManager()
-    return {
-      list: () => mgr.deps.repos.channels.list(),
-      agents: channelId => mgr.deps.repos.channelAgents.listByChannel(channelId),
-    }
-  })
-  // 平台通告面(插件 → Agent 异步结果回执):deliver 投递并唤醒,claim 轮询方认领。
-  // 未接线/测试脚手架下 manager 方法返回 false,插件侧降级为仅日志(行为同旧版)。
-  servicesExt.register('notify', async () => {
-    const m = await import('@/server/plugins/workshop')
-    const mgr = m.getWorkshopManager()
-    return {
-      deliver: notice => mgr.deliverPlatformNotice(notice),
-      claim: (tool, jobId) => mgr.claimPlatformNotice(tool, jobId),
-    }
-  })
-  servicesExt.register('plugins', async () => pluginManifest())
-}
-
-// ---- 启停状态(单一事实源:<home>/plugins-state.json;CLI/Web/宿主三方读写) ----
-//  入参 homeDir 由 modePaths().homeDir 给出($AW_HOME 优先),**不是配置根**。
+/**
+ * 插件运行时服务种子(ctx.* 懒绑定)
+ * (由 server/services/workshop/plugins/host.mjs 按职责拆出;内容逐行原文搬运)
+ */
+import { g } from './config.mjs'
+import { pluginManifest } from './api.mjs'
+
+export const servicesExt = (g.__awPluginServices ??= {
+  registry: new Map(),
+  /** 核心服务注册(name → 惰性 getter);宿主启动期 seed */
+  register(name, get) {
+    this.registry.set(String(name), get)
+  },
+  /** 插件供服务(自动加 `<plugin>.` 前缀;同前缀同名覆盖) */
+  provide(plugin, name, get) {
+    this.registry.set(`${plugin}.${String(name)}`, get)
+  },
+  names() {
+    return [...this.registry.keys()]
+  },
+  /** 取运行时服务对象(惰性求值并缓存;失败抛错由调用方兜底) */
+  async get(name) {
+    const get = this.registry.get(String(name))
+    if (!get) throw new Error(`未知运行时服务: ${name}(可用: ${this.names().join(', ')})`)
+    get._cache ??= get()
+    return await get._cache
+  },
+})
+
+/** 插件可获取的后端运行时对象(只读取数面;懒加载避免循环导入,失败即抛由插件兜底) */
+export async function seedRuntimeServices() {
+  if (servicesExt.registry.has('daq')) return
+  servicesExt.register('daq', async () => {
+    const storage = await import('@/server/services/workshop/daq/storage/index')
+    const nodes = await import('@/server/services/workshop/daq/daq-node.repo')
+    return {
+      query: q => storage.getTsdb().queryTagged(q),
+      nodes: () => nodes.getDaqNodeRepo().snapshot(),
+    }
+  })
+  servicesExt.register('lines', async () => {
+    const m = await import('@/server/services/workshop/dcw/dcw-line.repo')
+    const repo = m.getDcwLineRepo()
+    return { list: () => repo.all(), byId: id => repo.byId(id) }
+  })
+  servicesExt.register('channels', async () => {
+    const m = await import('@/server/plugins/workshop')
+    const mgr = m.getWorkshopManager()
+    return {
+      list: () => mgr.deps.repos.channels.list(),
+      agents: channelId => mgr.deps.repos.channelAgents.listByChannel(channelId),
+    }
+  })
+  // 平台通告面(插件 → Agent 异步结果回执):deliver 投递并唤醒,claim 轮询方认领。
+  // 未接线/测试脚手架下 manager 方法返回 false,插件侧降级为仅日志(行为同旧版)。
+  servicesExt.register('notify', async () => {
+    const m = await import('@/server/plugins/workshop')
+    const mgr = m.getWorkshopManager()
+    return {
+      deliver: notice => mgr.deliverPlatformNotice(notice),
+      claim: (tool, jobId) => mgr.claimPlatformNotice(tool, jobId),
+    }
+  })
+  // Agent 可读面(插件侧授权判定):绑定节点 ∪ 频道绑线产线。
+  // diag-bridge 等插件在读取产线数据前必须按调用者身份校验,不能拿全局只读面直读任意产线。
+  servicesExt.register('agentScope', async () => {
+    const m = await import('@/server/services/workshop/agents/industrial/tool-verify')
+    return {
+      readableLines: agentId => [...m.resolveRefFaces(agentId).readableLines],
+      boundNodes: agentId => [...m.resolveRefFaces(agentId).boundNodes],
+    }
+  })
+  servicesExt.register('plugins', async () => pluginManifest())
+}
+
+// ---- 启停状态(单一事实源:<home>/plugins-state.json;CLI/Web/宿主三方读写) ----
+//  入参 homeDir 由 modePaths().homeDir 给出($AW_HOME 优先),**不是配置根**。

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

@@ -44,6 +44,8 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
     this.deps.bus.notifyAgent({ agentId: this.agentId, state: 'busy', ...this.queueContext() })
     // 回合失败标记(须在 try 外声明,finally 依据它决定重投还是消费)
     let sawRunError = false
+    /** 失败原因(事件 error / 生成器抛错):写入任务 history,供事后诊断 */
+    let runErrorMessage = ''
     try {
       // 任务消息联动:assign → WORKING(自动接取;状态事件由 TaskEngine transition hooks 广播)
       // 仅 SUBMITTED/ASSIGNED 自动接取:WAITING(已有子任务)的任务由 SchedulerLoop/子任务汇总推进,
@@ -109,7 +111,10 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
             if (deltaText.length < 8000 && t) deltaText += t
             continue
           }
-          if (event.kind === 'error') sawRunError = true
+          if (event.kind === 'error') {
+            sawRunError = true
+            if (!runErrorMessage) runErrorMessage = `${event.error.code}: ${event.error.message}`
+          }
           // 无原生工具面的 harness(codex/dsh 等)以 shell/文本方式作业:回合 error 收束
           // 但已有实质输出时,不落入 FAILED(交由回合结束后的交付兜底按最终输出隐式收口)——
           // 否则「工作已做完、流断在收尾」的任务全部 FAILED→重试→CANCELED(实测 dsh)。
@@ -133,6 +138,7 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
       catch (err) {
         // run 生成器抛错(如 omp 子进程 spawn 失败):按回合失败走重投,不外抛断循环
         sawRunError = true
+        runErrorMessage = err instanceof Error ? err.message : String(err)
         // Harness 重建归因(§6.2):下回合若换了 client/进程,原因取自此处
         this.pendingHarnessFailure = 'RPC_BROKEN'
         log.error(`[AgentRuntime:${this.agentId}] 回合异常:`, err)
@@ -264,18 +270,27 @@ export abstract class AgentRuntimeMessage extends AgentRuntimeSupervise {
           else {
             const current = this.deps.taskEngine.get(taskId)
             if (current && current.assigneeId === this.agentId && current.state === 'WORKING') {
+              const at = new Date().toISOString()
+              const reason = runErrorMessage ? `: ${runErrorMessage.slice(0, 1000)}` : ''
+              const failureMessage = {
+                messageId: randomUUID(),
+                contextId: this.channelId,
+                role: 'ROLE_AGENT' as const,
+                parts: [{ text: `任务 ${taskId} 执行结束但无交付(harness 回合结束未产出)${reason},标记 FAILED 待重试` }],
+                metadata: { 'x-aw-system': 'task-failure' },
+              }
+              // 失败原因先入 history(status 事件只追加历史、不迁移状态),再迁移 FAILED
+              this.deps.taskEngine.applyEvent(taskId, {
+                kind: 'status',
+                status: { state: 'FAILED', message: failureMessage, timestamp: at },
+              }, fence)
               this.deps.taskEngine.transition(taskId, 'FAILED', this.agentId)
               this.emitExternal({
                 kind: 'status',
                 status: {
                   state: 'FAILED',
-                  message: {
-                    messageId: randomUUID(),
-                    contextId: this.channelId,
-                    role: 'ROLE_AGENT',
-                    parts: [{ text: `任务 ${taskId} 执行结束但无交付(harness 回合结束未产出),标记 FAILED 待重试` }],
-                  },
-                  timestamp: new Date().toISOString(),
+                  message: failureMessage,
+                  timestamp: at,
                 },
               })
             }

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

@@ -8,6 +8,8 @@ import type { AgentInfo } from '../../agents/agent-interface'
 import type { AgentRow, ChannelRow, WorkspaceRow } from '../../db/database'
 import { AppError, ErrorCodes } from '../../../../utils/errors'
 import { getDcwLineRepo } from '../../dcw/dcw-line.repo'
+import { getChannelPluginsRepo } from '../../db/channel-plugins.repo'
+import { getToolRegistryRepo } from '../../db/tool-registry.repo'
 import { assertHarnessUsable } from '../../agents/harness-availability'
 import { mkdirSync } from 'node:fs'
 import { parseJson } from '../../db/database'
@@ -156,12 +158,72 @@ export abstract class ManagerAdminChannel extends ManagerNotifications {
     }
     if (next === channel.lineId) return channel
     const updated = this.deps.repos.channels.setLine(channelId, next)!
+    // 换线即失效:旧产线的启停审批单按拒绝收敛,避免批准后仍按旧线语义执行
+    if (channel.lineId) {
+      try {
+        const { getToolApprovals } = await import('../../agents/tool-approvals')
+        const approvals = getToolApprovals()
+        for (const agent of this.deps.repos.channelAgents.listByChannel(channelId)) {
+          approvals.cancelPendingFor(agent.id, `line-start:${channel.lineId}`)
+          approvals.cancelPendingFor(agent.id, `line-stop:${channel.lineId}`)
+        }
+      }
+      catch { /* 审批服务未接线时不影响换线 */ }
+    }
+    // 绑线一致性(与 bindings/index.post.ts 的创建期约束同源):频道绑定到新线后,
+    // 成员留在其他产线的节点/配方绑定会让「频道 = 单产线工作区」失效,且工具仍可跨线读写。
+    // 换线时清理并取消其挂起审批;解绑产线(next='')不清理(纯协作频道可保留显式绑定)。
+    if (next) {
+      try {
+        const { getAgentNodeBindingRepo } = await import('../../agents/node-bindings.repo')
+        const { getDcwController } = await import('../../dcw/dcw-controller')
+        const { getDaqNodeRepo } = await import('../../daq/daq-node.repo')
+        const { getToolApprovals } = await import('../../agents/tool-approvals')
+        const { recordOps } = await import('../../ops/ops')
+        const repo = getAgentNodeBindingRepo()
+        const approvals = getToolApprovals()
+        let cleared = 0
+        for (const agent of this.deps.repos.channelAgents.listByChannel(channelId)) {
+          for (const binding of repo.byAgent(agent.id)) {
+            const boundLine = binding.kind === 'recipe'
+              ? (getDcwController().listRecipes().find(r => r.id === binding.nodeId)?.lineId ?? '')
+              : binding.kind === 'dcw'
+                ? (getDcwController().byId(binding.nodeId)?.lineId ?? '')
+                : (getDaqNodeRepo().byId(binding.nodeId)?.lineId ?? '')
+            if (!boundLine || boundLine === next) continue
+            if (repo.unbind(binding.id)) {
+              approvals.cancelPendingForBinding(agent.id, binding)
+              cleared++
+            }
+          }
+        }
+        if (cleared > 0) {
+          recordOps({
+            actor: 'system', actorName: 'system', actorKind: 'system',
+            action: 'channel.line.rebind', kind: 'line', targetKind: 'channel', targetId: channelId,
+            lineId: next,
+            summary: `频道换线「${channel.lineId || '(无)'}」→「${next}」:清理 ${cleared} 条跨线绑定并取消其挂起审批`,
+            detail: { fromLine: channel.lineId || '', toLine: next, cleared },
+          })
+        }
+      }
+      catch { /* 清理失败不阻断换线;工具层仍按绑定面+grant 复核(不放大权限) */ }
+    }
     // 与场景 prompt 变更同链路:回收成员运行时,下次装配注入新的产线简报
     await this.unloadChannelAgents(channelId)
     if (updated.leadAgentId) this.ensureChannelActive(channelId)
     return updated
   }
 
+  /**
+   * §13.3:当前人类发起者作用域(只读)。
+   * 供进程内工具分发层复核 —— omp 的 host_tool_call 不走 invokeHostTool,
+   * 此前只有 REST/MCP 路径生效,群成员 @Agent 时的高危工具限制被绕过。
+   */
+  invocationScopeOf(agentId: string) {
+    return this.activeInvocationScopes.get(agentId) ?? null
+  }
+
   /** v18:Agent 实例 → 其频道绑定的产线 id(只读扩权依据;未绑/找不到 = null) */
   channelLineBindingOf(agentId: string): string | null {
     const m = this.deps.repos.channelAgents.findById(agentId)
@@ -228,6 +290,12 @@ export abstract class ManagerAdminChannel extends ManagerNotifications {
     }
     // 记忆级联清理:成员私有行 + team 公共行(防残留行污染他 channel 的 FTS/team 检索域)
     this.deps.repos.memories.deleteByChannel(channelId)
+    // 工具治理级联:插件开关 + Channel 工具策略/选择行(无外键,必须显式删除)
+    try {
+      getChannelPluginsRepo().removeForChannel(channelId)
+      getToolRegistryRepo().removeForChannel(channelId)
+    }
+    catch { /* 工具治理表不可用不阻断删除(悬挂行读取时忽略) */ }
     // 定时任务级联清理(FK CASCADE 兜底;显式删除保证旧库无 FK 时也收敛)
     this.deps.repos.schedules?.removeByChannel(channelId)
     // workspace 挂载级联:不清理会留下"幽灵频道"(左栏有条目、右栏永空)——

package/server/services/workshop/runtime/manager/channel-template-constants.ts

@@ -0,0 +1,20 @@
+/**
+ * Channel 模板的纯常量(KB 集成名单 + 作业段提示词)。
+ *
+ * 单独成模块的原因:ManagerChannelTemplates 继承 ManagerTeams,模块图会拉入 nitro
+ * `#imports`(server/utils/config);纯常量不应因此无法被单测直接 import。
+ * channel-templates 侧保留同名 re-export,生产调用点不变。
+ */
+
+/** 携带「知识库集成」选项的模板:实例化时可显式启停 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 = `
+
+## 知识库集成(已启用 rag-bridge)
+本频道接入了 rag-knowledge 知识库,优化作业遵循「先检索、后行动、再沉淀」:
+1. 优化启动前,lead 与知识调优工程师先用 kb_agent(mode=sync) 检索知识库中与本场景相关的**数据分析结论**与**物理机理知识**(检索词带上产线/产品/关键物理量,如「注塑 保压 克重 波动」「烘箱温度 膜厚 滞后」);把检索所得的机理关系、历史阈值与经验教训作为探索方向、步长与安全边界的依据;
+2. 知识调优工程师是知识库的主要消费者与沉淀者:调优方案必须注明依据哪条知识;优化过程中若对某个现象拿不准,先查知识库再动手;worker 也可各自检索,但入库/沉淀由 lead 统一收口(可交知识调优工程师执行);
+3. 优化闭环收口后(目标达标或 judge 判定 keep),用 kb_agent(mode=async) 把本次经验沉淀入知识库:标题、类别(工艺经验/数据分析/故障案例)、问题、解决方案、关键数据(带单位的参数调整↔响应变化)。异步提交后无需等待,可继续汇报;入库结果用 kb_agent_status 查询;
+4. 若本频道同时启用深度诊断(diag-bridge):数据判读拿不准或质量异常时,先用 diag_run 发起根因诊断(异步,提交即返 task_id),完成后按 diag_status 返回的指引把报告经验经 kb_agent 入库,再把结论用于调优决策。`

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

@@ -12,19 +12,10 @@ import { parseJson } from '../../db/database'
 import { setHybridChannelProfile } from '../../aml/twin/channel-profile'
 import { defaultInjectionScene } from '../../aml/twin/physics-runtime'
 import { getChannelPluginsRepo } from '../../db/channel-plugins.repo'
+import { KNOWLEDGE_BASE_PROMPT_SECTION, KNOWLEDGE_BASE_TEMPLATE_IDS } from './channel-template-constants'
 
-/** 携带「知识库集成」选项的模板:实例化时可显式启停 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 = `
-
-## 知识库集成(已启用 rag-bridge)
-本频道接入了 rag-knowledge 知识库,优化作业遵循「先检索、后行动、再沉淀」:
-1. 优化启动前,lead 与知识调优工程师先用 kb_agent(mode=sync) 检索知识库中与本场景相关的**数据分析结论**与**物理机理知识**(检索词带上产线/产品/关键物理量,如「注塑 保压 克重 波动」「烘箱温度 膜厚 滞后」);把检索所得的机理关系、历史阈值与经验教训作为探索方向、步长与安全边界的依据;
-2. 知识调优工程师是知识库的主要消费者与沉淀者:调优方案必须注明依据哪条知识;优化过程中若对某个现象拿不准,先查知识库再动手;worker 也可各自检索,但入库/沉淀由 lead 统一收口(可交知识调优工程师执行);
-3. 优化闭环收口后(目标达标或 judge 判定 keep),用 kb_agent(mode=async) 把本次经验沉淀入知识库:标题、类别(工艺经验/数据分析/故障案例)、问题、解决方案、关键数据(带单位的参数调整↔响应变化)。异步提交后无需等待,可继续汇报;入库结果用 kb_agent_status 查询;
-4. 若本频道同时启用深度诊断(diag-bridge):数据判读拿不准或质量异常时,先用 diag_run 发起根因诊断(异步,提交即返 task_id),完成后按 diag_status 返回的指引把报告经验经 kb_agent 入库,再把结论用于调优决策。`
+// 常量本体已下沉到纯模块(避免单测 import 触发 nitro #imports);此处保持原导出面不变
+export { KNOWLEDGE_BASE_PROMPT_SECTION, KNOWLEDGE_BASE_TEMPLATE_IDS } from './channel-template-constants'
 
 export abstract class ManagerChannelTemplates extends ManagerTeams {
   /** 可见性感知 Channel 模板列表:普通用户 = 本人 + public(含内置);admin = 全量 */