agentworkshop 0.7.71 → 0.8.0

package/server/services/workshop/ontology/validator.ts

@@ -0,0 +1,218 @@
+/**
+ * 本体文档校验(零 DB 纯函数,可单测)。
+ *
+ * 只做结构/语义自洽判定;存在性、归属、读写能力等「活体」判定在
+ * semantic-binding.service(需要查 daq/dcw/recipe 真实对象)。
+ *
+ * fail-closed 原则:每条问题都带可行动 hint,禁止静默降级。
+ */
+import type { CompileIssue, EvidenceLevel, OntologyDraftDoc, OntologyEntity, OntologyRule } from './contracts'
+import {
+  ONTOLOGY_STATES,
+  RULE_ERROR_CODES,
+  entityUnitIssue,
+  evidenceLevelRank,
+  maxEvidenceLevel,
+  unitsCompatible,
+} from './contracts'
+
+export interface DraftStats {
+  entities: number
+  relations: number
+  rules: number
+  bindings: number
+  byState: Record<string, number>
+  byEvidence: Record<string, number>
+}
+
+export interface DraftValidationReport {
+  ok: boolean
+  issues: CompileIssue[]
+  stats: DraftStats
+}
+
+function issue(code: string, path: string, message: string, severity: 'error' | 'warning' = 'error', hint?: string, ruleId?: string): CompileIssue {
+  return { code, path, message, severity, hint, ruleId }
+}
+
+/** 规则 DSL 里出现的全部变量引用 */
+export function ruleVariableRefs(rule: OntologyRule): string[] {
+  const dsl = rule.dsl
+  switch (dsl.type) {
+    case 'bound': return [dsl.variableKey]
+    case 'rate': return [dsl.variableKey]
+    case 'linear_coupling': return [dsl.variableKey, dsl.ofKey]
+    case 'nonlinear': return [dsl.variableKey]
+    case 'state_condition': return [dsl.when.variableKey, dsl.forbid.variableKey]
+    case 'interlock': return dsl.variableKey ? [dsl.variableKey] : []
+    case 'informal': return []
+    default: return []
+  }
+}
+
+/** 规则证据能支持的最强级别 */
+export function ruleEvidenceLevel(rule: OntologyRule): EvidenceLevel | '' {
+  return maxEvidenceLevel(rule.evidence.map(e => e.level))
+}
+
+export function validateDraftDoc(doc: OntologyDraftDoc): DraftValidationReport {
+  const issues: CompileIssue[] = []
+  const entityByKey = new Map<string, OntologyEntity>()
+
+  // ---- 实体 ----
+  const seenKeys = new Set<string>()
+  doc.entities.forEach((entity, index) => {
+    if (seenKeys.has(entity.key)) {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, `entities[${index}]`, `实体 key「${entity.key}」重复`, 'error', '实体 key 必须在单份本体文档内唯一'))
+    }
+    seenKeys.add(entity.key)
+    entityByKey.set(entity.key, entity)
+    if (entity.unit) {
+      const unitIssue = entityUnitIssue(entity)
+      if (unitIssue) issues.push(unitIssue)
+    }
+    if (entity.kind === 'process_variable' || entity.kind === 'quality_variable') {
+      if (!entity.role) {
+        issues.push(issue(RULE_ERROR_CODES.ROLE_UNRESOLVED, `entities[${entity.key}]`,
+          `变量实体「${entity.key}」缺少 role`, 'warning',
+          '缺 role 时无法参与 bound/rate 规则编译(编译器会拒绝);建议补 control/target/disturbance/feature/state/guard/observation'))
+      }
+    }
+  })
+
+  // ---- 关系 ----
+  const relationIds = new Set<string>()
+  const relationTriples = new Set<string>()
+  doc.relations.forEach((rel, index) => {
+    const path = `relations[${index}]`
+    if (relationIds.has(rel.id)) issues.push(issue(RULE_ERROR_CODES.INVALID, path, `关系 id「${rel.id}」重复`))
+    relationIds.add(rel.id)
+    const triple = `${rel.srcKey}|${rel.dstKey}|${rel.kind}`
+    if (relationTriples.has(triple)) {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, path, `关系重复(${rel.srcKey} -${rel.kind}-> ${rel.dstKey})`))
+    }
+    relationTriples.add(triple)
+    if (rel.srcKey === rel.dstKey) {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, path, `关系 ${rel.id} 自引用(src 与 dst 相同)`, 'warning'))
+    }
+    if (!entityByKey.has(rel.srcKey)) {
+      issues.push(issue(RULE_ERROR_CODES.UNKNOWN_ENTITY, path, `关系 ${rel.id} 的 srcKey「${rel.srcKey}」不存在`, 'error', '先在 entities 里定义该实体'))
+    }
+    if (!entityByKey.has(rel.dstKey)) {
+      issues.push(issue(RULE_ERROR_CODES.UNKNOWN_ENTITY, path, `关系 ${rel.id} 的 dstKey「${rel.dstKey}」不存在`, 'error', '先在 entities 里定义该实体'))
+    }
+    const tier = rel.properties.evidenceTier
+    const declaredMax = maxEvidenceLevel(rel.evidence.map(e => e.level))
+    if (rel.evidence.length > 0 && evidenceLevelRank(tier) > evidenceLevelRank(declaredMax)) {
+      issues.push(issue(RULE_ERROR_CODES.EVIDENCE_INSUFFICIENT, path,
+        `关系 ${rel.id} 声明证据档 ${tier} 高于其证据最高级别 ${declaredMax || '无'}`,
+        'error', '补足对应级别证据,或下调 evidenceTier'))
+    }
+    if ((rel.properties.gainPerUnit !== undefined || rel.properties.lagMs !== undefined) && tier !== 'validated_control') {
+      issues.push(issue(RULE_ERROR_CODES.EVIDENCE_INSUFFICIENT, path,
+        `关系 ${rel.id} 携带增益/时滞,但证据档为 ${tier}`,
+        'error', '增益与时滞只能来自受控验证(validated_control:run+crosscheck+outcome);否则请留空,仅作候选影响'))
+    }
+  })
+
+  // ---- 规则 ----
+  const ruleIds = new Set<string>()
+  const ruleKeys = new Set<string>()
+  doc.rules.forEach((rule, index) => {
+    const path = `rules[${index}]`
+    if (ruleIds.has(rule.id)) issues.push(issue(RULE_ERROR_CODES.INVALID, path, `规则 id「${rule.id}」重复`))
+    ruleIds.add(rule.id)
+    if (ruleKeys.has(rule.key)) issues.push(issue(RULE_ERROR_CODES.INVALID, path, `规则 key「${rule.key}」重复`))
+    ruleKeys.add(rule.key)
+    if (rule.kind !== rule.dsl.type) {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, path,
+        `规则 ${rule.id} 的 kind(${rule.kind}) 与 dsl.type(${rule.dsl.type}) 不一致`,
+        'error', 'kind 决定编译形态,必须与 DSL 形态一致'))
+    }
+    for (const ref of ruleVariableRefs(rule)) {
+      if (!entityByKey.has(ref)) {
+        issues.push(issue(RULE_ERROR_CODES.UNKNOWN_ENTITY, path,
+          `规则 ${rule.id} 引用的实体「${ref}」不存在`, 'error', '先定义实体,或改用语义绑定后的平台变量', rule.id))
+      }
+    }
+    const level = ruleEvidenceLevel(rule)
+    // 硬约束只约束「数值强制」形态(bound/rate/nonlinear);state_condition 与 interlock
+    // 分别落运行时守卫 / PLC 解释层,不改变数值可行域,因此不要求 validated_control。
+    const numericHard = rule.constraintLevel === 'hard' && (rule.dsl.type === 'bound' || rule.dsl.type === 'rate' || rule.dsl.type === 'nonlinear')
+    if (numericHard && level !== 'validated_control') {
+      issues.push(issue(RULE_ERROR_CODES.EVIDENCE_INSUFFICIENT, path,
+        `规则 ${rule.id} 要求硬约束,但证据最高级别为 ${level || '无'}`,
+        'error', '硬约束只接受 validated_control(run+crosscheck+outcome);否则降为 soft 或改为 guard', rule.id))
+    }
+    if (rule.dsl.type === 'bound' && rule.dsl.min !== undefined && rule.dsl.max !== undefined && rule.dsl.min > rule.dsl.max) {
+      issues.push(issue(RULE_ERROR_CODES.RULE_CONFLICT, path,
+        `规则 ${rule.id} 的界区间为空(min ${rule.dsl.min} > max ${rule.dsl.max})`, 'error', '检查上下限是否写反', rule.id))
+    }
+    if (rule.dsl.type === 'nonlinear') {
+      // 简单阈值形态可由运行时守卫执行;复杂表达式需后端支持
+      const simple = /^\s*[a-z][a-z0-9_.]*\s*(<=|>=|<|>|==|!=)\s*-?\d+(?:\.\d+)?\s*$/.test(rule.dsl.expression)
+      if (!simple) {
+        issues.push(issue(RULE_ERROR_CODES.UNSUPPORTED_FORM, path,
+          `规则 ${rule.id} 的非线性表达式无法由运行时守卫执行`,
+          'warning', '建议改写为「变量 比较 阈值」形式,或落到 PhysicsSpec 由求解器/孪生后端支持', rule.id))
+      }
+    }
+  })
+
+  // ---- 语义绑定(草稿期) ----
+  const bindingIds = new Set<string>()
+  const bindingTriples = new Set<string>()
+  doc.bindings.forEach((binding, index) => {
+    const path = `bindings[${index}]`
+    if (bindingIds.has(binding.id)) issues.push(issue(RULE_ERROR_CODES.INVALID, path, `绑定 id「${binding.id}」重复`))
+    bindingIds.add(binding.id)
+    const triple = `${binding.entityKey}|${binding.platformKind}|${binding.platformId}`
+    if (bindingTriples.has(triple)) {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, path, `绑定重复(实体 ${binding.entityKey} → ${binding.platformKind}:${binding.platformId})`))
+    }
+    bindingTriples.add(triple)
+    const entity = entityByKey.get(binding.entityKey)
+    if (!entity) {
+      issues.push(issue(RULE_ERROR_CODES.UNKNOWN_ENTITY, path, `绑定 ${binding.id} 的实体「${binding.entityKey}」不存在`))
+      return
+    }
+    if (entity.unit && binding.unitDeclared && !unitsCompatible(entity.unit, binding.unitDeclared)) {
+      issues.push(issue(RULE_ERROR_CODES.UNIT_MISMATCH, path,
+        `绑定 ${binding.id} 的声明单位「${binding.unitDeclared}」与实体「${entity.key}」单位「${entity.unit}」量纲不相容`))
+    }
+    if (binding.unitDeclared && binding.unitTarget && !unitsCompatible(binding.unitDeclared, binding.unitTarget)) {
+      issues.push(issue(RULE_ERROR_CODES.UNIT_MISMATCH, path,
+        `绑定 ${binding.id} 的单位「${binding.unitDeclared}」与目标单位「${binding.unitTarget}」量纲不相容`))
+    }
+    if (!Number.isFinite(binding.scale) || binding.scale === 0) {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, path, `绑定 ${binding.id} 的 scale 必须为非零有限数(禁止兜底)`))
+    }
+    if (binding.platformKind === 'daq_node' && binding.direction !== 'read') {
+      issues.push(issue(RULE_ERROR_CODES.INVALID, path,
+        `绑定 ${binding.id} 把数采节点声明为 ${binding.direction}`, 'warning',
+        '平台数采节点通常是只读通道;写入应绑定 dcw_node 或 recipe_param(活体校验会拒绝)'))
+    }
+  })
+
+  const byState: Record<string, number> = {}
+  for (const state of ONTOLOGY_STATES) byState[state] = 0
+  for (const rule of doc.rules) byState[rule.status] = (byState[rule.status] ?? 0) + 1
+  const byEvidence: Record<string, number> = { candidate_influence: 0, observed_correlation: 0, validated_control: 0 }
+  for (const rule of doc.rules) {
+    const level = ruleEvidenceLevel(rule)
+    if (level) byEvidence[level] = (byEvidence[level] ?? 0) + 1
+  }
+
+  return {
+    ok: !issues.some(i => i.severity === 'error'),
+    issues,
+    stats: {
+      entities: doc.entities.length,
+      relations: doc.relations.length,
+      rules: doc.rules.length,
+      bindings: doc.bindings.length,
+      byState,
+      byEvidence,
+    },
+  }
+}

package/server/services/workshop/optimization/binding.repo.ts

@@ -111,6 +111,13 @@ export function createBindingRepo(db: DatabaseSync) {
       return row?.revision ?? 0
     },
 
+    /** 模型采纳重绑:绑定升到新 Profile 版本并 bump revision(在飞求解 BINDING_STALE 收敛)。 */
+    rebindVersion(id: string, toVersion: number): number {
+      const r = db.prepare('UPDATE optimizer_bindings SET profile_version = ?, revision = revision + 1, valid_from = ?, updated_at = ? WHERE id = ?')
+        .run(toVersion, new Date().toISOString(), new Date().toISOString(), id)
+      return Number(r.changes)
+    },
+
     removeByAgent(channelAgentId: string): number {
       const r = db.prepare('DELETE FROM optimizer_bindings WHERE channel_agent_id = ?').run(channelAgentId)
       return Number(r.changes)

package/server/services/workshop/optimization/contracts.ts

@@ -72,9 +72,23 @@ export interface OptimizationProfile {
   ownerUserId?: string
   /** 发布时冻结的问题结构 hash */
   problemIrHash?: string
+  /**
+   * 本体引用摘要(发布时冻结):**进 profileContentHash,绝不进 problemIrHash**。
+   * 漂移比对走独立校验(ONTOLOGY_PACK_DRIFTED),避免本体演化把旧 Profile
+   * 全部打成 PROBLEM_IR_CHANGED(与 D1/D12 同因)。
+   */
+  ontologyRefs?: OntologyRefSummary[]
   createdAt?: string
 }
 
+export interface OntologyRefSummary {
+  ontologyId: string
+  ontologyVersion: number
+  contentHash?: string
+  rulePackHash?: string
+  guardCount?: number
+}
+
 export function assertProfileSolverCompatible(profile: Pick<OptimizationProfile, 'solverRef' | 'modelRef' | 'problemTemplateRef'>): void {
   assertSolverSupportsArtifact(profile.solverRef, profile.modelRef.artifactKind, `profile model=${profile.modelRef.modelId}`)
   if (profile.solverRef === 'osqp_mpc@1' && profile.problemTemplateRef !== 'linear_mpc_quadratic@1') {

package/server/services/workshop/optimization/dispatch.service.ts

@@ -37,6 +37,7 @@ import { getDcwLineRepo } from '../dcw/dcw-line.repo'
 import { assertRecipeOpInterval } from '../dcw/recipe-op-anchor'
 import { getToolApprovals } from '../agents/tool-approvals'
 import { amlActivityForLine } from '../agents/industrial/aml-activity'
+import { assertOntologyUnchanged, evaluateOntologyGuardsForNodes } from '../ontology/ontology.service'
 import type { RecipeProposePayload } from '../agents/industrial/recipe-propose-tools'
 
 export function isOptimizerDispatchCard(nodeId: string): boolean {
@@ -342,6 +343,21 @@ export async function createDispatchCard(initiator: ResolvedUser, recommendation
     }
   })
   const { recipe } = loadRec(recommendationId)
+  // 本体运行时守卫(ONT):已发布本体的 block 级守卫对本次下发意图求值。
+  // 只增拒不放行;无本体/无守卫时零开销。批准时刻 D13 仍全量重验。
+  const ontologyGuard = evaluateOntologyGuardsForNodes(spec.lineId, paramRows.map(p => ({ nodeId: p.nodeId, from: p.from, to: p.to })))
+  if (ontologyGuard.blocked) {
+    const violation = ontologyGuard.violations[0]!
+    throw new AppError(409, 'ONTOLOGY_GUARD_BLOCKED',
+      `本体运行时守卫阻断下发:${violation.message}(规则 ${violation.ruleId};本体包 ${ontologyGuard.packHash.slice(0, 12)})`)
+  }
+  // Profile 冻结的本体引用漂移:独立校验(不进 IR hash,不变更 D13 八项语义)
+  const dispatchRun = db().prepare('SELECT profile_id AS profileId, profile_version AS profileVersion FROM optimizer_runs WHERE id = ?')
+    .get(rec.runId) as { profileId?: string, profileVersion?: number } | undefined
+  if (dispatchRun?.profileId) {
+    const dispatchProfileRow = getProfileRepo().get(dispatchRun.profileId, Number(dispatchRun.profileVersion ?? 1))
+    if (dispatchProfileRow) assertOntologyUnchanged(parseProfileRow(dispatchProfileRow).ontologyRefs)
+  }
   // 闸序预检(建卡时刻;批准时刻 D13 全量重验)
   const gate = await assertDispatchApprovable(recommendationId, { modelFirstMove, packages: [{ params: paramRows }] })
   if (!gate.ok) throw new AppError(gate.code.startsWith('DISPATCH_GATE') || gate.code === 'DISPATCH_STEP_EXCEEDED' ? 403 : 409, gate.code, gate.comment)

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

@@ -0,0 +1,256 @@
+/**
+ * Profile 模型采纳服务 —— Agent 迭代闭环的"采纳"环节(OW-adopt)。
+ *
+ * 闭环语义:Agent 训练出新模型(aml_job_submit→done)后,可以用
+ * `optimizer_profile_propose` 工具发起「采纳提议」:复制当前已发布 Profile
+ * 的全部求解配置、换上新模型工件、生成新草稿版本,并挂一张 HITL 卡。
+ * 人类批准 → **发布新版本 + 自动重绑**所有绑定在旧版本的 Agent(绑定 revision+1,
+ * 在飞求解按 BINDING_STALE 收敛,下一次 solve 即用新模型);拒绝 → 零写,意见回流。
+ *
+ * 治理不变量:
+ *  - 提议 = 草稿 + 卡,本身不改运行行为(旧版本继续求解);
+ *  - 发布只发生在人类批准之后(单一咽喉,dispatcher/decide 双入口同路由);
+ *  - 模型工件/求解器/模板兼容性在提议时校验(D21 矩阵,不兼容 422);
+ *  - 全链审计(actor 三态,publish/adopt/rebind 各一条)。
+ */
+import { AppError } from '../../../utils/errors'
+import { getAmlRuntime } from '../aml/runtime'
+import { recordOps } from '../ops/ops'
+import { getProfileRepo, parseProfileRow } from './profile.repo'
+import { getBindingRepo } from './binding.repo'
+import { assertProfileSolverCompatible, type OptimizationProfile } from './contracts'
+import type { ProblemTemplateRef, SolverRef } from '../process-model/contracts'
+import { securityRecipeDispatchTimeoutMs } from '../settings'
+import { createLogger } from '../logger'
+
+import { getToolApprovals } from '../agents/tool-approvals'
+
+const log = createLogger('optimizer.profile-adopt')
+
+export const PROFILE_ADOPT_PREFIX = 'optimizer-profile:'
+
+export function isProfileAdoptCard(nodeId: string): boolean {
+  return nodeId.startsWith(PROFILE_ADOPT_PREFIX)
+}
+
+export interface ProposeAdoptionInput {
+  /** 发起 Agent 的 channel 实例 id(HITL 卡挂在其频道) */
+  agentInstanceId: string
+  /** 人类发起时为用户 id;Agent 发起传 agentId(actorKind='agent') */
+  initiatorId: string
+  initiatorKind?: 'user' | 'agent'
+  profileId: string
+  modelId: string
+  /** 可选切换问题模板/求解器(不兼容 → 422,D21 矩阵) */
+  templateRef?: ProblemTemplateRef
+  solverRef?: SolverRef
+  /** 提议理由(必填;审批卡展示) */
+  reason: string
+  /** 依赖注入(单测 stub 用) */
+  deps?: {
+    requestApproval?: (agentId: string, nodeId: string, kind: 'dcw', detail: string, opts?: { title?: string, timeoutMs?: number, payload?: unknown }) => Promise<{ approved: boolean, comment: string, choice: number | null }>
+  }
+}
+
+export interface ProposeAdoptionResult {
+  cardId: string
+  profileId: string
+  version: number
+  priorVersion: number
+  modelId: string
+  decision: { approved: boolean, comment: string, choice: number | null }
+  published: boolean
+  rebindCount: number
+}
+
+/** 提议采纳:建草稿新版本 + 挂 HITL 卡 + 等待裁决(approved 时已完成发布与重绑)。 */
+export async function proposeProfileAdoption(input: ProposeAdoptionInput): Promise<ProposeAdoptionResult> {
+  const repo = getProfileRepo()
+  const published = repo.latestPublished(input.profileId)
+  if (!published) {
+    throw new AppError(404, 'PROFILE_NOT_PUBLISHED', `Profile ${input.profileId} 没有已发布版本;采纳以已发布版本为基线`)
+  }
+  const model = getAmlRuntime().repo.model.get(input.modelId)
+  if (!model) throw new AppError(404, 'MODEL_NOT_FOUND', `模型 ${input.modelId} 不存在(先经 AML 训练登记)`)
+
+  const prior = parseProfileRow(published)
+  const version = published.version + 1
+  const nextProfile: OptimizationProfile = {
+    ...prior,
+    version,
+    status: 'draft',
+    modelRef: {
+      modelId: input.modelId,
+      artifactKind: (model.artifactKind || 'onnx_one_step@1') as OptimizationProfile['modelRef']['artifactKind'],
+      modelInterface: (model.modelInterface || 'one_step') as OptimizationProfile['modelRef']['modelInterface'],
+      artifactHash: model.artifactHash || '',
+      stage: 'candidate',
+    },
+    ...(input.templateRef ? { problemTemplateRef: input.templateRef } : {}),
+    ...(input.solverRef ? { solverRef: input.solverRef } : {}),
+  }
+  // D21 分派矩阵:工件×模板×求解器不兼容在此显式拒绝(不产生草稿)
+  assertProfileSolverCompatible(nextProfile)
+  repo.insert(nextProfile, input.initiatorId)
+
+  const cardId = `${PROFILE_ADOPT_PREFIX}${input.profileId}@${version}`
+  const detail = [
+    `模型采纳提议:${input.profileId} v${published.version} → v${version}`,
+    `新模型:${input.modelId}(${nextProfile.modelRef.artifactKind},hash ${String(nextProfile.modelRef.artifactHash).slice(0, 12)}…)`,
+    nextProfile.problemTemplateRef !== prior.problemTemplateRef || nextProfile.solverRef !== prior.solverRef
+      ? `求解配置变更:模板 ${prior.problemTemplateRef}→${nextProfile.problemTemplateRef},求解器 ${prior.solverRef}→${nextProfile.solverRef}`
+      : `求解配置不变(模板 ${nextProfile.problemTemplateRef} / ${nextProfile.solverRef})`,
+    `理由:${input.reason}`,
+    `批准 = 冻结发布 v${version} 并把绑定在 v${published.version} 的 Agent 自动重绑(在飞求解 BINDING_STALE 收敛);拒绝 = 零写。`,
+  ].join('\n')
+
+  recordOps({
+    actor: input.initiatorId,
+    actorName: input.initiatorId,
+    actorKind: input.initiatorKind ?? 'agent',
+    action: 'optimizer.profile.adopt_propose',
+    kind: 'system',
+    targetKind: 'optimizer_profile',
+    targetId: `${input.profileId}@${version}`,
+    summary: `提议采纳模型 ${input.modelId} → ${input.profileId}@${version}(卡 ${cardId})`,
+    detail: { profileId: input.profileId, version, priorVersion: published.version, modelId: input.modelId, reason: input.reason },
+  })
+
+  const requestApproval = input.deps?.requestApproval
+    ?? ((agentId: string, nodeId: string, kind: 'dcw', detail_: string, opts?: { title?: string, timeoutMs?: number, payload?: unknown }) =>
+      getToolApprovals().request(agentId, nodeId, kind, detail_, opts))
+
+  const decision = await requestApproval(input.agentInstanceId, cardId, 'dcw', detail, {
+    title: `模型采纳:${input.profileId} → v${version}`,
+    timeoutMs: securityRecipeDispatchTimeoutMs(),
+    payload: { schemaVersion: 1, profileId: input.profileId, version, priorVersion: published.version, modelId: input.modelId },
+  })
+
+  if (!decision.approved) {
+    return { cardId, profileId: input.profileId, version, priorVersion: published.version, modelId: input.modelId, decision: { approved: false, comment: decision.comment, choice: decision.choice ?? null }, published: false, rebindCount: 0 }
+  }
+  // 批准路径的发布/重绑在单一咽喉(decideProfileAdoption)已完成;此处防御式复核
+  const publishedRow = repo.get(input.profileId, version)
+  const rebindCount = countBindingsOn(input.profileId, version)
+  return {
+    cardId,
+    profileId: input.profileId,
+    version,
+    priorVersion: published.version,
+    modelId: input.modelId,
+    decision: { approved: true, comment: decision.comment, choice: decision.choice ?? null },
+    published: publishedRow?.status === 'published',
+    rebindCount,
+  }
+}
+
+function countBindingsOn(profileId: string, version: number): number {
+  return getBindingRepo().listAll(500).filter(b => b.profileId === profileId && b.profileVersionNumber === version).length
+}
+
+export interface DecideAdoptionInput {
+  /** 审批单 id(ap-…;listPending 的主键) */
+  cardId: string
+  /** 卡的 nodeId(optimizer-profile:<id>@<v>);缺省时经审批单反查 */
+  nodeId?: string
+  approved: boolean
+  comment: string
+  actingUser: { id: string, name?: string }
+  via: 'hitl/respond' | 'decide-endpoint'
+  /** 依赖注入(单测 stub);缺省走真实 ToolApprovalService(卡必须在册) */
+  deps?: {
+    decideApproval?: (id: string, approved: boolean, comment: string, by: string, name: string) => void
+  }
+}
+
+/** 卡落定(真实面:审批必须在册;stub 面:直接回调)。失败不击穿咽喉主流程。 */
+function settle(deps: DecideAdoptionInput['deps'], cardId: string, approved: boolean, comment: string, by: string, name: string): void {
+  try {
+    const decide = deps?.decideApproval ?? ((id: string, ok: boolean, msg: string, by2: string, name2: string) => getToolApprovals().decide(id, ok, msg, by2, name2))
+    decide(cardId, approved, comment, by, name)
+  }
+  catch (err) {
+    log.warn(`[profile-adopt] 卡落定失败(不影响裁决结果):${err instanceof Error ? err.message : String(err)}`)
+  }
+}
+
+export interface DecideAdoptionResult {
+  handled: boolean
+  approved: boolean
+  comment: string
+  code?: string
+  published?: { profileId: string, version: number, rebindCount: number }
+}
+
+/** 单一咽喉:optimizer-profile:* 卡的裁决 → 发布 + 重绑 + 审计(业务拒绝在咽喉内落定)。 */
+export async function decideProfileAdoption(input: DecideAdoptionInput): Promise<DecideAdoptionResult> {
+  // nodeId 解析:分支显式传入优先;否则经审批单反查(卡 id ≠ nodeId,两个命名空间)
+  const nodeId = input.nodeId
+    ?? getToolApprovals().listPending().find(a => a.id === input.cardId)?.nodeId
+    ?? input.cardId
+  if (!isProfileAdoptCard(nodeId)) return { handled: false, approved: input.approved, comment: input.comment }
+  const parsed = nodeId.slice(PROFILE_ADOPT_PREFIX.length).split('@')
+  const profileId = parsed[0] ?? ''
+  const version = Number(parsed[1])
+  if (!profileId || !Number.isInteger(version)) {
+    throw new AppError(422, 'PROFILE_ADOPT_CARD_INVALID', `采纳卡 nodeId 形状非法:${nodeId}`)
+  }
+  const repo = getProfileRepo()
+  const row = repo.get(profileId, version)
+  if (!row) {
+    settle(input.deps, input.cardId, false, `Profile ${profileId}@${version} 已不存在;按拒收敛`, input.actingUser.id, input.actingUser.name ?? '')
+    return { handled: true, approved: false, comment: '目标 Profile 版本不存在', code: 'PROFILE_NOT_FOUND' }
+  }
+
+  if (!input.approved) {
+    // 拒绝:草稿保留(可修订后重新 propose,新卡重走),零写
+    settle(input.deps, input.cardId, false, input.comment || '采纳提议被拒绝', input.actingUser.id, input.actingUser.name ?? '')
+    recordOps({
+      actor: input.actingUser.id, actorName: input.actingUser.name ?? input.actingUser.id, actorKind: 'user',
+      action: 'optimizer.profile.adopt_reject', kind: 'system',
+      targetKind: 'optimizer_profile', targetId: `${profileId}@${version}`,
+      summary: `拒绝模型采纳 ${profileId}@${version}(草稿保留,零写)`,
+      detail: { profileId, version, comment: input.comment, via: input.via },
+    })
+    return { handled: true, approved: false, comment: input.comment || '采纳提议被拒绝', code: 'PROFILE_ADOPT_REJECTED' }
+  }
+
+  // 批准:发布冻结 + 自动重绑(旧 published 版本 → 新版本;revision+1 使在飞求解 BINDING_STALE 收敛)
+  const priorVersion = version - 1
+  try {
+    repo.publish(profileId, version)
+    const rebindCount = rebindBindings(profileId, priorVersion, version)
+    recordOps({
+      actor: input.actingUser.id, actorName: input.actingUser.name ?? input.actingUser.id, actorKind: 'user',
+      action: 'optimizer.profile.adopt', kind: 'system',
+      targetKind: 'optimizer_profile', targetId: `${profileId}@${version}`,
+      summary: `批准并发布 ${profileId}@${version}(重绑 ${rebindCount} 个绑定;来自采纳卡)`,
+      detail: { profileId, version, priorVersion, rebindCount, via: input.via, comment: input.comment },
+    })
+    settle(input.deps, input.cardId, true, input.comment || `已发布 v${version},重绑 ${rebindCount} 个绑定`, input.actingUser.id, input.actingUser.name ?? '')
+    return { handled: true, approved: true, comment: input.comment, published: { profileId, version, rebindCount } }
+  }
+  catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    settle(input.deps, input.cardId, false, `发布失败,按拒收敛:${message}`, input.actingUser.id, input.actingUser.name ?? '')
+    recordOps({
+      actor: input.actingUser.id, actorName: input.actingUser.name ?? input.actingUser.id, actorKind: 'user',
+      action: 'optimizer.profile.adopt_reject', kind: 'system', level: 'error',
+      targetKind: 'optimizer_profile', targetId: `${profileId}@${version}`,
+      summary: `采纳发布失败按拒收敛 ${profileId}@${version}:${message}`,
+      detail: { profileId, version, error: message, via: input.via },
+    })
+    return { handled: true, approved: false, comment: `发布失败:${message}`, code: 'PROFILE_ADOPT_PUBLISH_FAILED' }
+  }
+}
+
+function rebindBindings(profileId: string, fromVersion: number, toVersion: number): number {
+  const repo = getBindingRepo()
+  let count = 0
+  for (const b of repo.listAll(500)) {
+    if (b.profileId !== profileId || b.profileVersionNumber !== fromVersion) continue
+    const moved = repo.rebindVersion(b.id, toVersion)
+    if (moved > 0) count += 1
+  }
+  return count
+}

package/server/services/workshop/optimization/profile.repo.ts

@@ -28,6 +28,8 @@ export interface ProfileRow {
   problemIrHash: string
   /** 发布不可变校验:内容 hash(不含 status/createdAt/problemIrHash) */
   contentHash: string
+  /** 本体引用冻结(JSON 数组;缺省 '[]' = 无本体约束域) */
+  ontologyRefsJson: string
   createdAt: string
   updatedAt: string
 }
@@ -38,6 +40,7 @@ const COLS = `id, version, name, model_ref AS modelRef, model_artifact_hash AS m
   process_spec_ref AS processSpecRef,
   solver_ref AS solverRef, solver_version AS solverVersion, condition_ids_json AS conditionIdsJson,
   status, owner_user_id AS ownerUserId, problem_ir_hash AS problemIrHash, content_hash AS contentHash,
+  ontology_refs_json AS ontologyRefsJson,
   created_at AS createdAt, updated_at AS updatedAt`
 
 export function profileContentHash(profile: OptimizationProfile): string {
@@ -61,12 +64,13 @@ export function createProfileRepo(db: DatabaseSync) {
       db.prepare(`INSERT INTO optimizer_profiles
         (id, version, name, model_ref, model_artifact_hash, model_artifact_kind, model_interface,
          problem_template_ref, problem_config_json, process_spec_ref, solver_ref, solver_version, condition_ids_json,
-         status, owner_user_id, problem_ir_hash, content_hash, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+         status, owner_user_id, problem_ir_hash, content_hash, ontology_refs_json, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
         .run(profile.id, profile.version, profile.name ?? '', profile.modelRef.modelId, profile.modelRef.artifactHash,
           profile.modelRef.artifactKind, profile.modelRef.modelInterface, profile.problemTemplateRef,
           JSON.stringify(profile.problemConfig ?? {}), profile.processSpecRef ?? '', profile.solverRef, profile.solverVersion,
-          JSON.stringify(profile.conditionIds ?? []), profile.status, ownerUserId, profile.problemIrHash ?? '', contentHash, now, now)
+          JSON.stringify(profile.conditionIds ?? []), profile.status, ownerUserId, profile.problemIrHash ?? '', contentHash,
+          JSON.stringify(profile.ontologyRefs ?? []), now, now)
       return this.get(profile.id, profile.version)!
     },
 
@@ -92,6 +96,11 @@ export function createProfileRepo(db: DatabaseSync) {
       return (r.v ?? 0) + 1
     },
 
+    /** 最近已发布版本(采纳服务以它为基线;无则 undefined) */
+    latestPublished(id: string): ProfileRow | undefined {
+      return db.prepare(`SELECT ${COLS} FROM optimizer_profiles WHERE id = ? AND status = 'published' ORDER BY version DESC LIMIT 1`).get(id) as unknown as ProfileRow | undefined
+    },
+
     /** 发布:冻结 problemIrHash;published 行禁止原地修改(服务层拒绝 UPDATE)。 */
     publish(id: string, version: number, problemIrHash?: string): ProfileRow {
       const row = this.get(id, version)
@@ -153,6 +162,13 @@ export function parseProfileRow(row: ProfileRow): OptimizationProfile {
     status: row.status,
     ownerUserId: row.ownerUserId,
     problemIrHash: row.problemIrHash || undefined,
+    ontologyRefs: (() => {
+      try {
+        const parsed = JSON.parse(row.ontologyRefsJson || '[]') as OptimizationProfile['ontologyRefs']
+        return parsed && parsed.length > 0 ? parsed : undefined
+      }
+      catch { return undefined }
+    })(),
     createdAt: row.createdAt,
   }
 }