agentworkshop 0.7.71 → 0.8.1

package/server/services/workshop/agents/industrial/ops-tools.ts

@@ -16,7 +16,7 @@ import { getDcwParamRepo } from '../../dcw/param-map.repo'
 import { getOps } from '../../ops/ops'
 import { settingOf } from '../../settings'
 import { fanoutQuery, windowOf } from './audit-query'
-import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload } from './recipe-gate'
+import { assertRecipeCreate, assertRecipeOperation, recipeApprovalPayload, type ActiveRecipeContext } from './recipe-gate'
 
 // ================================================================
 // 运维日志 / Recipe 变更史查询(Agent 自查面:负责产线 scoped)
@@ -779,7 +779,7 @@ export async function toolRecipeUpdate(agentId: string, args: {
           const old = recipe.params.find(x => x.nodeId === String(p.node_id).trim())?.value
           return { nodeId: String(p.node_id).trim(), name: node?.name ?? String(p.node_id), from: old ?? null, to: Number(p.value), unit: node?.unit }
         }),
-        runId: gate.activeRunId,
+        context: gate.activeContext,
       }) },
     )
     if (!gateDecision.approved) {
@@ -788,7 +788,7 @@ export async function toolRecipeUpdate(agentId: string, args: {
       }
     }
     if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId })
+    const stale = await revalidateApprovedAction(agentId, recipe, 'update', 'recipe_update', { recipe_id: recipeId }, gate.activeContext)
     if (stale) return stale
   }
   // 旧值快照(repo.update 原地改写 recipe.params,事后再取会把 before 读成新值)
@@ -887,7 +887,7 @@ export async function toolRecipeRollback(agentId: string, args: {
       recipe.id,
       `${emergency ? '【应急豁免频控】' : ''}配方回退:「${recipe.name}」→ ${toLastGood ? '已知良好批次冻结' : `v${version}`}${dispatch ? '(统一回退:定义回退+整批重下发)' : '(仅定义回退)'} | 理由:${reason} | 批准=执行回退;拒绝可附指导`,
       `${emergency ? '【应急】' : ''}配方回退审批`,
-      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, runId: gate.activeRunId }), ...(emergency ? { emergency: true } : {}) } },
+      { payload: { ...recipeApprovalPayload('rollback', recipe.id, recipe.name, { reason, context: gate.activeContext }), ...(emergency ? { emergency: true } : {}) } },
     )
     gateApprovalId = gateDecision.id
     if (!gateDecision.approved) {
@@ -896,11 +896,15 @@ export async function toolRecipeRollback(agentId: string, args: {
       }
     }
     if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId })
+    const stale = await revalidateApprovedAction(agentId, recipe, 'rollback', 'recipe_rollback', { recipe_id: recipeId }, gate.activeContext)
     if (stale) return stale
   }
   try {
     if (dispatch) {
+      if (gate.hitlRequired) {
+        const staleAtDispatch = approvedContextError(agentId, recipe, 'rollback', gate.activeContext)
+        if (staleAtDispatch) return staleAtDispatch
+      }
       const { recipe: updated, run, definitionNoop } = await getDcwController().rollbackRecipeAndDispatch(recipeId, {
         version: toLastGood ? undefined : version,
         toLastGood,
@@ -979,23 +983,46 @@ async function hitlDispatchGate(agentId: string, recipeId: string, detail: strin
 }
 
 /**
- * 审批返回「批准」后的二次授权复核(2026-10-18):审批可能挂起数分钟,
- * 期间绑定/产线授权/运行批次都可能被撤销。批准不等于授权仍然有效:
+ * 审批返回「批准」后的二次状态复核:审批可能挂起数分钟,
+ * 期间绑定/产线授权/活动产线上下文都可能变化。批准不等于授权与上下文仍然有效:
  *  - 重新跑 assertRecipeOperation(绑定/二级认证/运行门);
+ *  - 将当前 line/product/recipe/run 元组与审批时快照比较,变化即拒绝;
  *  - 重新跑 grant-guard(频道属主的产线 grant,收权即失活)。
- * 任一失败 → 本次不执行,回包说明原因(Agent 可据此重新申请)。
+ * 任一失败 → 本次不执行,回包说明原因(Agent 可据此核实上下文并重新申请)。
  */
+function approvedContextError(
+  agentId: string,
+  recipe: { id: string, name: string, lineId?: string, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
+  op: 'update' | 'dispatch' | 'trial' | 'rollback',
+  expectedContext: ActiveRecipeContext,
+): { text: string, isError: true } | null {
+  const currentGate = assertRecipeOperation(agentId, recipe, op)
+  if (!currentGate.ok) {
+    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${currentGate.text}`, isError: true }
+  }
+  const current = currentGate.activeContext
+  if (current.lineId !== expectedContext.lineId
+    || current.runId !== expectedContext.runId
+    || current.recipeId !== expectedContext.recipeId
+    || current.productId !== expectedContext.productId) {
+    return {
+      text: '人工已批准,但审批期间产线/产品/配方/批次上下文已变化,本次未执行。请核查当前运行上下文后重新提交。',
+      isError: true,
+    }
+  }
+  return null
+}
+
 export async function revalidateApprovedAction(
   agentId: string,
   recipe: { id: string, name: string, lineId?: string, access?: { requireAuth?: boolean, authorizedAgentIds?: string[] } },
   op: 'update' | 'dispatch' | 'trial' | 'rollback',
   toolName: string,
   args: Record<string, unknown>,
+  expectedContext: ActiveRecipeContext,
 ): Promise<{ text: string, isError: true } | null> {
-  const again = assertRecipeOperation(agentId, recipe, op)
-  if (!again.ok) {
-    return { text: `人工已批准,但审批期间授权已失效,本次未执行:${again.text}`, isError: true }
-  }
+  const initialContextError = approvedContextError(agentId, recipe, op, expectedContext)
+  if (initialContextError) return initialContextError
   try {
     // manager 未装配(单测/嵌入)→ 只做绑定与运行门复核;装配后叠加产线 grant 复核
     const g = globalThis as typeof globalThis & {
@@ -1011,6 +1038,11 @@ export async function revalidateApprovedAction(
   catch (err) {
     return { text: `人工已批准,但审批后权限复核不可用,本次未执行:${err instanceof Error ? err.message : String(err)}。请稍后重试。`, isError: true }
   }
+  // Grant lookup is asynchronous. Re-read the active tuple after that await so
+  // queued line/run changes cannot pass between the initial comparison and the
+  // caller's dispatch continuation.
+  const changedAfterGrantCheck = approvedContextError(agentId, recipe, op, expectedContext)
+  if (changedAfterGrantCheck) return changedAfterGrantCheck
   return null
 }
 
@@ -1086,7 +1118,7 @@ export async function toolRecipeTrial(agentId: string, args: {
             const old = recipe.params.find(x => x.nodeId === p.nodeId)?.value
             return { nodeId: p.nodeId, name: node?.name ?? p.nodeId, from: old ?? null, to: p.value, unit: node?.unit }
           }),
-          runId: gate.activeRunId,
+          context: gate.activeContext,
         }), ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1097,8 +1129,10 @@ export async function toolRecipeTrial(agentId: string, args: {
       }
       // 人工附言随批准回执回流(Agent 与审计都能看到放行时人的原话)
       if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId })
+      const stale = await revalidateApprovedAction(agentId, recipe, 'trial', 'recipe_trial', { recipe_id: recipeId }, gate.activeContext)
       if (stale) return stale
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'trial', gate.activeContext)
+      if (staleAtDispatch) return staleAtDispatch
     }
     const run = await getDcwController().applyRecipe(recipeId, { overrides: list, trial: true, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent
@@ -1187,7 +1221,7 @@ export async function toolRecipeApply(agentId: string, args: {
             const node = getDcwController().byId(p.nodeId)
             return { nodeId: p.nodeId, name: node?.name ?? p.nodeId, from: null, to: p.value, unit: node?.unit }
           }),
-          runId: gate.activeRunId,
+          context: gate.activeContext,
         }), recipeVersion: dispatch.version, ...(emergency ? { emergency: true } : {}) } },
       )
       gateApprovalId = gateDecision.id
@@ -1198,7 +1232,7 @@ export async function toolRecipeApply(agentId: string, args: {
       }
       // 人工附言随批准回执回流(与 recipe_trial 同口径)
       if (gateDecision.comment) hitlNote = `\n人工附言:${gateDecision.comment}`
-      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId })
+      const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_apply', { recipe_id: recipeId }, gate.activeContext)
       if (stale) return stale
     }
     // 放在最后一次 await 之后,与 applyRecipe 的同步取值/建批之间不再让出执行权。
@@ -1206,6 +1240,10 @@ export async function toolRecipeApply(agentId: string, args: {
     if (!currentRecipe || JSON.stringify(currentRecipe) !== approvedDefinition) {
       return { text: '配方在审批期间已变更,与本次审批展示的快照不一致,本次未执行。请核查最新配方后重新提交 recipe_apply。', isError: true }
     }
+    if (gate.hitlRequired) {
+      const staleAtDispatch = approvedContextError(agentId, recipe, 'dispatch', gate.activeContext)
+      if (staleAtDispatch) return staleAtDispatch
+    }
     // 完整覆盖集让控制器复制每个已批准值,逐参数异步写期间也不再共享可变配方参数。
     const run = await getDcwController().applyRecipe(recipeId, { overrides: dispatch.params, agentDispatch: true, agentApprovalId: gateApprovalId, emergency })
     // ACK 鉴定三段口径(2026-10-08):ok 只是命令受理,未证实/失败必须如实回给 Agent

package/server/services/workshop/agents/industrial/optimizer-tools.ts

@@ -17,6 +17,7 @@ import { getEligibilityRepo } from '../../process-model/eligibility'
 import { getProcessModelSpecRepo } from '../../process-model/spec.repo'
 import { cancel, getRunStatus, solve } from '../../optimization/manager'
 import { assertRecommendationUsable } from '../../optimization/recommendation.service'
+import { proposeProfileAdoption } from '../../optimization/profile-adopt.service'
 import { deriveDualState } from '../../optimization/crosscheck.service'
 
 function ok(payload: unknown): HostToolResult {
@@ -191,3 +192,83 @@ export function hasOptimizerBinding(agentId: string): boolean {
     return false
   }
 }
+
+/**
+ * 模型采纳提议(OW-adopt):把 AML 新训练登记的模型采纳为指定 Profile 的新版本。
+ *
+ * AI-first 闭环的"采纳"环节:复制当前已发布 Profile 的全部求解配置 → 换新模型工件 →
+ * 草稿新版本 → 挂 HITL 卡等待人类裁决。批准(单一咽喉)= 冻结发布 + 自动重绑所有
+ * 绑定在旧版本的 Agent(revision+1,在飞求解 BINDING_STALE 收敛);拒绝/超时 = 零写。
+ *
+ * 治理:工具属写族(grant-guard operate);Agent 必须已绑定该 Profile(防越权提议);
+ * 兼容性(D21 矩阵)在服务层提议时校验;发布仅发生在人类批准后。
+ */
+export async function toolOptimizerProfilePropose(agentId: string, args: Record<string, unknown>): Promise<HostToolResult> {
+  try {
+    const bindings = listBindingsForAgent(agentId)
+    if (bindings.length === 0) {
+      return { text: '本 Agent 没有优化器绑定;模型采纳必须由已绑定该 Profile 的 Agent 发起(先在 Channel 设置里绑定)。', isError: true }
+    }
+    const modelId = String(args.model_id ?? '').trim()
+    if (!modelId) return { text: 'model_id 必填(aml_job_submit 训练完成登记的模型 id;aml_leaderboard/aml_model_find 可查)。', isError: true }
+    const profileId = String(args.profile_id ?? '').trim() || (() => {
+      const bound = bindings.map(b => b.profileId)
+      return new Set(bound).size === 1 ? bound[0]! : ''
+    })()
+    if (!profileId) {
+      return { text: `本 Agent 绑定了多个 Profile(${bindings.map(b => b.profileId).join(', ')});必须显式传 profile_id。`, isError: true }
+    }
+    if (!bindings.some(b => b.profileId === profileId)) {
+      return { text: `Profile ${profileId} 不在本 Agent 的绑定面内,不能代为提议采纳(越权拒绝)。`, isError: true }
+    }
+    const reason = String(args.reason ?? '').trim()
+    if (!reason) return { text: 'reason 必填:为什么采纳新模型(证据:训练指标对比/互校结论/业务动因)。', isError: true }
+
+    const result = await proposeProfileAdoption({
+      agentInstanceId: agentId,
+      initiatorId: agentId,
+      initiatorKind: 'agent',
+      profileId,
+      modelId,
+      templateRef: args.template_ref as Parameters<typeof proposeProfileAdoption>[0]['templateRef'],
+      solverRef: args.solver_ref as Parameters<typeof proposeProfileAdoption>[0]['solverRef'],
+      reason,
+      profileName: str(args.profile_name),
+      profileDescription: str(args.profile_description),
+    })
+
+    if (!result.decision.approved) {
+      return {
+        text: [
+          `采纳提议未被批准(卡 ${result.cardId}):`,
+          `${result.profileId} v${result.priorVersion} → v${result.version}(模型 ${result.modelId})`,
+          `裁决:${result.decision.comment || '拒绝/超时'}`,
+          '草稿已保留(零写);可修订理由后重新提议,或由管理员经 REST 发布。',
+        ].join('\n'),
+        isError: true,
+      }
+    }
+    if (!result.published) {
+      return {
+        text: [
+          `⚠️ 采纳提议获批准,但发布未由裁决咽喉完成(卡 ${result.cardId}):`,
+          `${result.profileId} v${result.priorVersion} → v${result.version} 仍为草稿;请管理员经 REST/管理面发布,或重新发起采纳。`,
+        ].join('\n'),
+        isError: true,
+      }
+    }
+    return {
+      text: [
+        '✅ 模型采纳完成(HITL 批准):',
+        `${result.profileId} v${result.priorVersion} → v${result.version}(published)`,
+        `模型:${result.modelId};重绑绑定 ${result.rebindCount} 个(revision+1,在飞求解 BINDING_STALE 收敛)`,
+        `裁决意见:${result.decision.comment || '(无)'}`,
+        '下一次 optimizer_solve 即使用新模型;旧版本保留可回退(retire/rebind 走管理面)。',
+      ].join('\n'),
+    }
+  }
+  catch (err) {
+    const message = err instanceof AppError ? `${err.code}: ${err.message}` : String(err)
+    return { text: `模型采纳提议失败:${message}`, isError: true }
+  }
+}

package/server/services/workshop/agents/industrial/recipe-gate.ts

@@ -20,12 +20,19 @@ import { getActiveLineRun } from '../../dcw/line-run'
 
 export type RecipeOp = 'update' | 'dispatch' | 'trial' | 'rollback' | 'create'
 
+export type ActiveRecipeContext = {
+  lineId: string
+  runId: string
+  recipeId: string
+  productId: string
+}
+
 export type RecipeGateResult
-  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeRunId: string }
+  = | { ok: true, binding: AgentNodeBinding, hitlRequired: boolean, activeContext: ActiveRecipeContext }
     | { ok: false, text: string }
 
 /** 运行门:该配方当前是否有活动批次(未结束的 run) */
-export function activeRunOfRecipe(recipeId: string): { id: string } | null {
+export function activeRunOfRecipe(recipeId: string): ActiveRecipeContext | null {
   const run = getDcwController().listRuns().find(r => r.recipeId === recipeId && !r.endedAt)
   if (!run) return null
   // 反僵尸交叉校验(鲁棒性):DB 行未结束 ≠ 产线在运行 —— 多次 apply/崩溃/重启会泄漏
@@ -33,8 +40,13 @@ export function activeRunOfRecipe(recipeId: string): { id: string } | null {
   // 权威运行态是 line-run 注册表(内存+line-runs.json 落盘,崩溃可恢复):
   // run 所属产线必须在注册表中运行,且注册表的活跃批次就是本批次。
   const active = getActiveLineRun(run.lineId)
-  if (!active || active.runId !== run.id) return null
-  return { id: run.id }
+  if (!active || active.runId !== run.id || active.recipeId !== recipeId) return null
+  return {
+    lineId: active.lineId,
+    runId: active.runId,
+    recipeId: active.recipeId,
+    productId: active.productId,
+  }
 }
 
 /** 统一鉴权门:绑定 → 二级认证 → 运行门;返回绑定与 HITL 判定(不做挂起,挂起由调用方执行) */
@@ -74,7 +86,7 @@ export function assertRecipeOperation(
   // ⑤ 全局开关兼容位:security.recipeDispatchApproval 开启时即便 auto 也挂审批(保留语义)
   const globalGate = false // 由调用方按 settingOf('security.recipeDispatchApproval') 叠加(本模块不依赖设置服务)
   void globalGate
-  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual, activeRunId: run.id }
+  return { ok: true, binding, hitlRequired: binding.mode === 'manual' || lineManual, activeContext: run }
 }
 
 /** 新建配方的授权门(尚无 recipe 可绑定):要求 Agent 在该线至少有一个写向绑定
@@ -116,6 +128,7 @@ export function assertRecipeCreate(agentId: string, lineId: string): { ok: true,
 export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName: string, extra: {
   reason: string
   params?: Array<{ nodeId: string, name: string, from: number | null, to: number, unit?: string }>
+  context?: ActiveRecipeContext
   runId?: string
 }): Record<string, unknown> {
   return {
@@ -126,6 +139,6 @@ export function recipeApprovalPayload(op: RecipeOp, recipeId: string, recipeName
     recipeName,
     reason: extra.reason,
     ...(extra.params ? { params: extra.params } : {}),
-    ...(extra.runId ? { runId: extra.runId } : {}),
+    ...(extra.context ? { context: { ...extra.context }, runId: extra.context.runId } : extra.runId ? { runId: extra.runId } : {}),
   }
 }

package/server/services/workshop/agents/industrial/recipe-propose-tools.ts

@@ -278,7 +278,7 @@ export async function toolRecipePropose(agentId: string, args: {
   }
 
   // 批准不等于授权仍有效:复核绑定/认证/运行门/产线 grant(审批期间可能被撤销)
-  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId })
+  const stale = await revalidateApprovedAction(agentId, recipe, 'dispatch', 'recipe_propose', { recipe_id: recipeId }, gate.activeContext)
   if (stale) return stale
 
   // ---------- ⑦b 批准(choice 已由 decide 链 fail-closed 归一):选定包整批下发 ----------

package/server/services/workshop/agents/industrial/tool-verify.ts

@@ -168,7 +168,16 @@ function chainDeny(faces: ToolRefFaces, toolName: string, args: Record<string, u
   ], faces, hint, { param, value: id, lineId })
 }
 
-type ChainKind = 'dataset' | 'job' | 'model' | 'plan' | 'scene' | 'binding' | 'run' | 'recommendation'
+function draftLineId(draftJson: string): string {
+  try {
+    return (JSON.parse(draftJson || '{}') as { lineId?: string }).lineId ?? ''
+  }
+  catch {
+    return ''
+  }
+}
+
+type ChainKind = 'dataset' | 'job' | 'model' | 'plan' | 'scene' | 'binding' | 'run' | 'recommendation' | 'ontology_draft' | 'ontology_version'
 
 /** 优化运行/建议 → 所属 Agent(经 binding 反查);不存在返回 null(交工具兜底)。 */
 function optimizerOwnership(id: string, kind: 'run' | 'recommendation'): { agentId: string } | null {
@@ -209,6 +218,27 @@ function chainLineOf(kind: ChainKind, id: string, args: Record<string, unknown>)
     const p = getTrainingPlan(id)
     return p ? { lineId: p.lineId, createdBy: '' } : null
   }
+  // 本体草稿:归属 = 草稿属主(agent 起草时 owner=agentId);取不到 → 交工具自身
+  if (kind === 'ontology_draft') {
+    const row = rt.db.prepare('SELECT owner_user_id AS ownerUserId, draft_json AS draftJson FROM ontology_drafts WHERE id = ?').get(id) as { ownerUserId?: string, draftJson?: string } | undefined
+    if (!row) return null
+    let lineId = draftLineId(row.draftJson ?? '')
+    if (!lineId) {
+      const v = rt.db.prepare('SELECT line_id AS lineId FROM ontology_versions WHERE id = (SELECT ontology_id FROM ontology_drafts WHERE id = ?) ORDER BY version DESC LIMIT 1').get(id) as { lineId?: string } | undefined
+      lineId = v?.lineId ?? ''
+    }
+    return { lineId, createdBy: row.ownerUserId ?? '' }
+  }
+  // 本体版本:id@version 或 (ontology_id, version);归属 = 版本产线
+  if (kind === 'ontology_version') {
+    const ontologyId = id
+    const wantsVersion = args.version !== undefined ? Number(args.version) : Number.NaN
+    const row = Number.isInteger(wantsVersion)
+      ? rt.db.prepare('SELECT line_id AS lineId FROM ontology_versions WHERE id = ? AND version = ?').get(ontologyId, wantsVersion) as { lineId?: string } | undefined
+      : rt.db.prepare(`SELECT line_id AS lineId FROM ontology_versions WHERE id = ? AND status = 'published' ORDER BY version DESC LIMIT 1`).get(ontologyId) as { lineId?: string } | undefined
+    if (!row) return null
+    return { lineId: row.lineId ?? '', createdBy: '' }
+  }
   // scene:需带版本(scene_id 多版本并存);取不到记录 → 交工具自身
   const version = String(args.scene_version ?? '').trim()
   if (!version) return null
@@ -372,7 +402,7 @@ export function verifyToolReferences(agentId: string, toolName: string, args: Re
       const mine = row.createdBy === agentId
       const readable = !!row.lineId && faces.readableLines.has(row.lineId)
       if (!mine && !readable) {
-        const label = { dataset: '数据集', job: '训练作业', model: '模型', plan: '建模任务', scene: '场景' }[chain.kind]
+        const label = { dataset: '数据集', job: '训练作业', model: '模型', plan: '建模任务', scene: '场景', ontology_draft: '本体草稿', ontology_version: '本体版本' }[chain.kind]
         return chainDeny(faces, toolName, args, chain.param, id, label, row.lineId)
       }
     }

package/server/services/workshop/agents/omp-agent/supervision-history.ts

@@ -0,0 +1,38 @@
+import type { AgentWorkspace } from '../agent-interface'
+import type { AgentSessionEvent } from '../adapters/omp-rpc-client'
+import { toolArgsPreview } from '../prompt-builder'
+
+/** Compact, history-compatible audit line for a host tool used during lead supervision. */
+export function supervisionToolHistoryMessage(event: AgentSessionEvent): string | null {
+  const toolName = typeof event.toolName === 'string' && event.toolName ? event.toolName : 'tool'
+  if (event.type === 'tool_execution_start') {
+    return `🔧 ${toolName}${toolArgsPreview(event.args)}`
+  }
+  if (event.type !== 'tool_execution_end') return null
+
+  const rawResult = event.result ?? event.output ?? ''
+  let summary: string
+  if (typeof rawResult === 'string') {
+    summary = rawResult
+  }
+  else {
+    try {
+      summary = JSON.stringify(rawResult) ?? ''
+    }
+    catch {
+      summary = '(不可序列化结果)'
+    }
+  }
+  summary = summary.slice(0, 300)
+  return `🔧 ${toolName} ${event.isError === true ? '❌ 失败' : '✅ 完成'}${summary ? `: ${summary}` : ''}`
+}
+
+/** Persist a supervisor host-tool event against the active root task when it is still open. */
+export async function recordSupervisionToolHistory(
+  workspace: Pick<AgentWorkspace, 'reportTask'>,
+  taskId: string,
+  event: AgentSessionEvent,
+): Promise<void> {
+  const message = supervisionToolHistoryMessage(event)
+  if (message) await workspace.reportTask({ taskId, message })
+}

package/server/services/workshop/agents/omp-agent/tools-steer.ts

@@ -7,6 +7,7 @@ import type { AgentEvent, AgentRunContext, AgentRunRequest, SupervisionDecision,
 import type { HostToolCallRequest } from '../adapters/omp-rpc-client'
 import { extractJsonArray, parseSteerBanner, peerPrompt, supervisePrompt, systemManual, workerPrompt } from '../prompt-builder'
 import { log } from './helpers'
+import { recordSupervisionToolHistory } from './supervision-history'
 
 export abstract class OmpRpcAgentImplToolsSteer extends OmpRpcAgentImplLifecycle {
   /** 引擎无关工具面:REST/MCP 桥直调与 omp 内部 host_tool_call 共用同一实现 */
@@ -97,6 +98,12 @@ export abstract class OmpRpcAgentImplToolsSteer extends OmpRpcAgentImplLifecycle
     return new Promise<SupervisionDecision[]>((resolve) => {
       let assistantText = ''
       let resolved = false
+      const activeRootTask = snapshot.tasks.find(task =>
+        task.id === snapshot.activeRootId
+        && task.assigneeId === this.selfAgentId
+        && ['SUBMITTED', 'ASSIGNED', 'WORKING', 'WAITING'].includes(task.state),
+      )
+      let taskHistoryWrites = Promise.resolve()
 
       const finish = (decisions: SupervisionDecision[]) => {
         if (resolved) return
@@ -107,7 +114,7 @@ export abstract class OmpRpcAgentImplToolsSteer extends OmpRpcAgentImplLifecycle
         unsub()
         if (hardTimer) clearTimeout(hardTimer)
         signalUnsub?.()
-        resolve(decisions)
+        void taskHistoryWrites.then(() => resolve(decisions), () => resolve(decisions))
       }
 
       const abortTurn = (reason: string): void => {
@@ -118,6 +125,16 @@ export abstract class OmpRpcAgentImplToolsSteer extends OmpRpcAgentImplLifecycle
       }
 
       const unsub = this.client!.onEvent((event) => {
+        if (activeRootTask && (event.type === 'tool_execution_start' || event.type === 'tool_execution_end')) {
+          // Lead supervision is not a workerTurn, so its host-tool events do not
+          // pass through promptAndStream's task event mapper. Persist them on the
+          // active root while it is open, preserving tool-call/result chronology.
+          taskHistoryWrites = taskHistoryWrites.then(async () => {
+            await recordSupervisionToolHistory(ctx.workspace, activeRootTask.id, event)
+          }).catch((err) => {
+            log.error(`[OmpRpcAgent:${this.selfAgentId}] supervise task-history write failed:`, err)
+          })
+        }
         if (event.type === 'message_update' && event.assistantMessageEvent?.type === 'text_delta') {
           this.streaming = true
           assistantText += event.assistantMessageEvent.delta ?? ''

package/server/services/workshop/agents/tool-reference-spec.ts

@@ -17,7 +17,7 @@ import type { ToolRefKind as _RefKind } from './tool-reference-kinds'
 export type { ToolRefKind } from './tool-reference-kinds'
 
 /** 链式引用类别(经谱系回溯判定归属) */
-export type ToolChainKind = 'dataset' | 'job' | 'model' | 'plan' | 'scene' | 'binding' | 'run' | 'recommendation'
+export type ToolChainKind = 'dataset' | 'job' | 'model' | 'plan' | 'scene' | 'binding' | 'run' | 'recommendation' | 'ontology_draft' | 'ontology_version'
 
 export interface ToolRefRule {
   param: string

package/server/services/workshop/aml/aml.repo.ts

@@ -460,6 +460,22 @@ export function createAmlRepo(db: DatabaseSync) {
       updateNote(id: string, note: string): void {
         db.prepare('UPDATE aml_models SET note = ? WHERE id = ?').run(note, id)
       },
+      /** 人读身份维护(Agent/REST 共用):只改 label/description,不改阶段与工件 */
+      updateIdentity(id: string, patch: { label?: string, description?: string }): void {
+        const sets: string[] = []
+        const args: unknown[] = []
+        if (patch.label !== undefined) {
+          sets.push('label = ?')
+          args.push(patch.label.slice(0, 200))
+        }
+        if (patch.description !== undefined) {
+          sets.push('description = ?')
+          args.push(patch.description.slice(0, 500))
+        }
+        if (!sets.length) return
+        args.push(id)
+        db.prepare(`UPDATE aml_models SET ${sets.join(', ')} WHERE id = ?`).run(...(args as never[]))
+      },
     },
   }
 }

package/server/services/workshop/aml/twin/physics-spec.ts

@@ -1,3 +1,5 @@
+import { dimensionsCompatible, dimensionOf } from '@/shared/dimensions'
+
 export const PHYSICS_SPEC_VERSION = 'physics-spec.v1' as const
 export const PHYSICS_OPERATORS = ['add', 'sub', 'mul', 'div', 'pow', 'exp', 'log', 'min', 'max', 'clamp'] as const
 export type PhysicsOperator = typeof PHYSICS_OPERATORS[number]
@@ -67,15 +69,6 @@ export interface PhysicsSpecValidationResult {
 const OPS = new Set<string>(PHYSICS_OPERATORS)
 const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_.:-]*$/
 const RESERVED = new Set(['__proto__', 'prototype', 'constructor'])
-const DIMENSIONLESS = new Set(['', '1', 'ratio', 'fraction', 'percent', '%'])
-const UNIT_DIMENSIONS: Record<string, string> = {
-  s: 'time', sec: 'time', ms: 'time', min: 'time', h: 'time',
-  degc: 'temperature', c: 'temperature', k: 'temperature', degf: 'temperature',
-  pa: 'pressure', kpa: 'pressure', mpa: 'pressure', bar: 'pressure', psi: 'pressure',
-  g: 'mass', kg: 'mass', mg: 'mass',
-  m: 'length', cm: 'length', mm: 'length', km: 'length',
-  a: 'current', v: 'voltage', w: 'power', j: 'energy', n: 'force',
-}
 
 function record(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === 'object' && !Array.isArray(value)
@@ -89,19 +82,10 @@ function idOk(value: unknown): value is string {
 function addIssue(issues: PhysicsSpecIssue[], path: string, code: string, message: string, severity: 'error' | 'warning' = 'error') {
   issues.push({ path, code, message, severity })
 }
-function unitKey(unit: string | undefined): string {
-  return (unit ?? '').trim().toLowerCase().replace('°', 'deg')
-}
-function dimension(unit: string | undefined): string {
-  const key = unitKey(unit)
-  if (DIMENSIONLESS.has(key)) return 'dimensionless'
-  if (UNIT_DIMENSIONS[key]) return UNIT_DIMENSIONS[key]
-  if (key.includes('/') || key.includes('*') || key.includes('^')) return `compound:${key}`
-  return key ? `unit:${key}` : 'scalar'
-}
-function compatible(a: string, b: string): boolean {
-  return a === '*' || b === '*' || a === b || (a === 'dimensionless' && b === 'scalar') || (b === 'dimensionless' && a === 'scalar')
-}
+/** 量纲归一与相容判定复用 shared/dimensions(本体与 PhysicsSpec 共用一张表;℃ 缺口在此已修) */
+const dimension = dimensionOf
+const compatible = dimensionsCompatible
+
 function normalizeExpr(value: unknown): PhysicsExpression | undefined {
   if (finite(value)) return value
   if (!record(value)) return undefined

package/server/services/workshop/daq/bus/index.ts

@@ -22,16 +22,23 @@ export async function getDaqQueue(): Promise<DaqQueuePort> {
 
 /** 重连/初始装配:按 infra 判定结果(重新)构建 MQTT 或进程内队列 */
 export async function rebuildDaqQueue(online: boolean, url?: string | null): Promise<DaqQueuePort> {
-  // 换装前释放旧 adapter(mqtt 连接 / inproc 泵),防重建泄漏
-  await g.__daqQueue?.close?.()
   if (!online || !url) {
-    if (g.__daqQueue?.backend !== 'inproc') {
-      g.__daqQueue = new InProcQueueAdapter()
+    // Reuse an in-process adapter without closing it. close() clears consumers and
+    // stops its pump; getDaqQueue() will not initialize an existing instance again.
+    if (g.__daqQueue?.backend === 'inproc') {
       await g.__daqQueue.init()
-      log.warn('[daq-queue] 降级进程内队列')
+      return g.__daqQueue
     }
+    // When falling back from MQTT, install a fresh adapter; the controller reattaches
+    // its consumer after this replacement.
+    await g.__daqQueue?.close?.()
+    g.__daqQueue = new InProcQueueAdapter()
+    await g.__daqQueue.init()
+    log.warn('[daq-queue] 降级进程内队列')
     return g.__daqQueue
   }
+  // Release the previous adapter before a transition to MQTT.
+  await g.__daqQueue?.close?.()
   try {
     const adapter = new MqttQueueAdapter(url)
     await adapter.init()

package/server/services/workshop/daq/storage/index.ts

@@ -2,19 +2,20 @@
  * TsdbPort 工厂 —— 配置驱动(daqInfraUrls 提供真实 Timescale URL),降级 SQLite 仿真。
  * 单例挂 globalThis;rebuildTsdb() 支持重连时从降级实例切回真实实例。
  */
-import { createLogger } from '../../logger'
+import { createLogger } from '../../logger'
 import { SqliteTimeSeriesAdapter } from './sqlite.adapter'
 import { TimescaleAdapter } from './timescale.adapter'
 import type { TsdbPort } from './tsdb-port'
 
-const log = createLogger('daq.tsdb')
-
+const log = createLogger('daq.tsdb')
+
 interface DaqTsdbState { current?: TsdbPort, initError?: unknown }
 const g = globalThis as typeof globalThis & { __daqTsdbState?: DaqTsdbState }
 
 function makeFallback(reason: string): TsdbPort {
   const dev = new SqliteTimeSeriesAdapter()
-  dev.init()
+  // init 失败不再静默:读路径有 ensureDb 惰性自愈兜底,但这里必须留下证据
+  dev.init().catch(err => log.error(`[daq-tsdb] SQLite 降级实例初始化失败(读路径将自愈重试):`, err instanceof Error ? err.message : err))
   log.warn(`[daq-tsdb] ${reason} → 已降级 SQLite 时序仿真`)
   return dev
 }
@@ -27,7 +28,7 @@ export const tsdbReady: Promise<void> = (() => {
     if (!url) {
       // 无配置(启动插件尚未装配):先占位仿真库;插件随后按 infra 状态 rebuild
       const dev = new SqliteTimeSeriesAdapter()
-      dev.init()
+      dev.init().catch(err => log.error('[daq-tsdb] SQLite 占位实例初始化失败(读路径将自愈重试):', err instanceof Error ? err.message : err))
       st.current = dev
     }
     else {