agentworkshop 0.7.70 → 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/access.ts

@@ -0,0 +1,210 @@
+/**
+ * Optimizer / Process-Model 统一操作授权(D16)。
+ *
+ * 口径:登录 + 角色只是入口;每一次资源读/写前必须经此函数判定"该主体能否触达该资源"。
+ * 三类资源三种归属:
+ *   - Profile:用户私有(owner_user_id;admin 全读) —— 配置管理权
+ *   - 规格/数据集/资格/试验/训练:产线可见性(requireLineMode readonly) —— 产线配置权
+ *   - 绑定/运行/建议/互校/下发/能力:Channel 成员(agent 实例归属) —— 成员调用权
+ *
+ * 授权性拒绝(403)统一写 1 条 `tool.call.denied` 审计(resource/op/actor/reason),
+ * 与 grant-guard 同口径;/logs 可追溯越权尝试。404/422(资源不存在/形状非法)不算授权失败,不审计。
+ *
+ * 直接经 rest-auth 读 globalThis.__workshopManager:避免静态 import plugins/workshop,
+ * 便于单测注入假管理器(与 rest-auth 同约束)。
+ */
+import { AppError } from '../../../utils/errors'
+import type { ResolvedUser } from '../../../api/workshop/caller'
+import { lineMode } from '../permissions'
+import { recordOps } from '../ops/ops'
+import { getProfileRepo } from './profile.repo'
+import { getProcessModelSpecRepo } from '../process-model/spec.repo'
+import { getAmlRuntime } from '../aml/runtime'
+import { getBindingRepo } from './binding.repo'
+import { getRunRepo } from './run.repo'
+import { assertAgentAccess } from './rest-auth'
+
+export type OptimizationOperation
+  = | 'read' | 'write' | 'publish' | 'evaluate' | 'solve' | 'crosscheck' | 'dispatch' | 'cancel'
+
+export type OptimizationResource
+  = | { kind: 'profile', id: string, version?: number }
+    | { kind: 'spec', id: string, version?: number }
+    | { kind: 'dataset', id: string }
+    | { kind: 'eligibility', specId: string }
+    | { kind: 'experiment', lineId?: string }
+    | { kind: 'train', lineId: string }
+    | { kind: 'binding' | 'capabilities', agentInstanceId: string }
+    | { kind: 'run' | 'recommendation' | 'crosscheck' | 'dispatch', runId?: string, agentInstanceId?: string }
+
+export interface OptimizationAccessContext {
+  lineId?: string
+  agentInstanceId?: string
+  channelId?: string
+}
+
+/** 授权性拒绝:先落审计再抛 403(审计失败不影响拒绝语义,与 grant-guard 同) */
+function deny(user: ResolvedUser, resource: OptimizationResource, operation: OptimizationOperation, reason: string): never {
+  try {
+    recordOps({
+      actor: user.id,
+      actorName: user.name,
+      actorKind: 'user',
+      action: 'tool.call.denied',
+      kind: 'system',
+      level: 'warn',
+      targetKind: 'optimizer',
+      targetId: `${resource.kind}:${'id' in resource ? String(resource.id) : 'agentInstanceId' in resource ? String(resource.agentInstanceId) : 'runId' in resource ? String(resource.runId ?? '') : 'specId' in resource ? String(resource.specId) : ''}`,
+      summary: `Optimizer 访问被拒(${resource.kind}/${operation}):${reason}`,
+      detail: { resource: resource.kind, operation, reason, userId: user.id },
+    })
+  }
+  catch { /* 审计失败不影响拒绝语义 */ }
+  throw new AppError(403, 'AUTHZ_DENIED', reason)
+}
+
+/** Profile 可见性:owner 或 admin(列表过滤同口径,静默过滤不审计) */
+export function canSeeProfile(user: ResolvedUser, row: { ownerUserId?: string, owner_user_id?: string } | undefined): boolean {
+  if (!row) return false
+  if (user.role === 'admin') return true
+  const owner = row.ownerUserId ?? row.owner_user_id ?? ''
+  return owner === user.id
+}
+
+function resolveSpecLineId(specId: string, version?: number): { lineId: string, ownerId: string } {
+  const row = getProcessModelSpecRepo().get(specId, version)
+  if (!row) throw new AppError(404, 'SPEC_NOT_FOUND', `ProcessModelSpec ${specId} 不存在`)
+  return { lineId: row.lineId, ownerId: row.ownerUserId ?? '' }
+}
+
+function resolveDatasetLineId(datasetId: string): { lineId: string, ownerId: string } {
+  let row: { lineId?: string, createdBy?: string } | undefined
+  try {
+    row = getAmlRuntime().repo.dataset.get(datasetId)
+  }
+  catch {
+    // AML 未初始化(单测/插件未启动)→ 按不存在处理
+    row = undefined
+  }
+  if (!row) throw new AppError(404, 'DATASET_NOT_FOUND', `数据集 ${datasetId} 不存在`)
+  return { lineId: row.lineId ?? '', ownerId: row.createdBy ?? '' }
+}
+
+function resolveRunAgent(runId: string | undefined, agentInstanceId: string | undefined): string {
+  if (agentInstanceId) return agentInstanceId
+  if (!runId) throw new AppError(422, 'RUN_REF_REQUIRED', '必须提供 runId 或 agentInstanceId 以定位归属')
+  const run = getRunRepo().getRun(runId)
+  if (!run) throw new AppError(404, 'RUN_NOT_FOUND', `运行 ${runId} 不存在`)
+  const binding = getBindingRepo().get(run.bindingId)
+  if (!binding) throw new AppError(404, 'BINDING_NOT_FOUND', `运行 ${runId} 的绑定 ${run.bindingId} 不存在`)
+  return binding.channelAgentId
+}
+
+/**
+ * 统一入口:返回解析后的资源上下文(行 lineId / agentInstanceId / channelId),
+ * 供内层闸序(dispatch D10)消费,不得用另一套规则重算归属。
+ */
+export function assertOptimizationAccess(
+  user: ResolvedUser,
+  operation: OptimizationOperation,
+  resource: OptimizationResource,
+): OptimizationAccessContext {
+  switch (resource.kind) {
+    case 'profile': {
+      const row = getProfileRepo().get(resource.id, resource.version)
+      if (!row) throw new AppError(404, 'PROFILE_NOT_FOUND', `Profile ${resource.id} 不存在`)
+      if (!canSeeProfile(user, row)) deny(user, resource, operation, `Profile ${resource.id} 不属于当前用户(仅 owner 或 admin 可访问)`)
+      return { agentInstanceId: undefined }
+    }
+    case 'spec': {
+      const { lineId } = resolveSpecLineId(resource.id, resource.version)
+      try {
+        lineMode(user, lineId)
+      }
+      catch (err) {
+        deny(user, resource, operation, err instanceof AppError ? err.message : `无产线 ${lineId} 权限`)
+      }
+      return { lineId }
+    }
+    case 'dataset': {
+      const { lineId } = resolveDatasetLineId(resource.id)
+      try {
+        lineMode(user, lineId)
+      }
+      catch (err) {
+        deny(user, resource, operation, err instanceof AppError ? err.message : `无产线 ${lineId} 权限`)
+      }
+      return { lineId }
+    }
+    case 'eligibility': {
+      const { lineId } = resolveSpecLineId(resource.specId)
+      try {
+        lineMode(user, lineId)
+      }
+      catch (err) {
+        deny(user, resource, operation, err instanceof AppError ? err.message : `无产线 ${lineId} 权限`)
+      }
+      return { lineId }
+    }
+    case 'experiment': {
+      const lineId = resource.lineId
+      if (!lineId) throw new AppError(422, 'LINE_REQUIRED', 'lineId 必填(试验按产线归属授权)')
+      try {
+        lineMode(user, lineId)
+      }
+      catch (err) {
+        deny(user, resource, operation, err instanceof AppError ? err.message : `无产线 ${lineId} 权限`)
+      }
+      return { lineId }
+    }
+    case 'train': {
+      try {
+        lineMode(user, resource.lineId)
+      }
+      catch (err) {
+        deny(user, resource, operation, err instanceof AppError ? err.message : `无产线 ${resource.lineId} 权限`)
+      }
+      return { lineId: resource.lineId }
+    }
+    case 'binding':
+    case 'capabilities': {
+      const { channelId } = assertAgentAccess(user, resource.agentInstanceId, { manage: operation === 'write' })
+      return { agentInstanceId: resource.agentInstanceId, channelId }
+    }
+    case 'run':
+    case 'recommendation':
+    case 'crosscheck':
+    case 'dispatch': {
+      const agentInstanceId = resolveRunAgent(resource.runId, resource.agentInstanceId)
+      const { channelId } = assertAgentAccess(user, agentInstanceId)
+      return { agentInstanceId, channelId }
+    }
+  }
+}
+
+/** 配置动作审计(SW1.6):每次成功变更恰 1 条,actor 恒为发起用户 */
+export function recordConfigAction(
+  user: ResolvedUser,
+  action: string,
+  target: { kind: string, id: string },
+  summary: string,
+  detail: Record<string, unknown> = {},
+  lineId?: string,
+): void {
+  try {
+    recordOps({
+      actor: user.id,
+      actorName: user.name,
+      actorKind: 'user',
+      action,
+      kind: 'line',
+      level: 'info',
+      targetKind: target.kind,
+      targetId: target.id,
+      lineId: lineId ?? '',
+      summary,
+      detail: { ...detail, userId: user.id },
+    })
+  }
+  catch { /* 审计失败不阻断业务 */ }
+}

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

@@ -0,0 +1,135 @@
+/**
+ * OptimizerBinding 仓储。作用域 = (workspace, channel, channel_agent, profile)。
+ * channel_agent_id 是 channel_agents.id(实例身份),绝不是 agents.id(模板)。
+ */
+import type { DatabaseSync } from 'node:sqlite'
+import { AppError } from '../../../utils/errors'
+import type { BindingMode } from './contracts'
+import { getAmlRuntime } from '../aml/runtime'
+
+export interface BindingRow {
+  id: string
+  workspaceId: string
+  channelId: string
+  channelAgentId: string
+  profileId: string
+  profileVersionNumber: number
+  /** "profileId@version"(与 OptimizationProfile 的版本引用同格式) */
+  profileVersion: string
+  capabilities: string[]
+  mode: BindingMode
+  validFrom: string
+  validTo: string | null
+  revision: number
+  createdAt: string
+}
+
+const COLS = `id, workspace_id AS workspaceId, channel_id AS channelId, channel_agent_id AS channelAgentId,
+  profile_id AS profileId, profile_version AS profileVersionNumber, capabilities_json AS capabilitiesJson,
+  mode, valid_from AS validFrom, valid_to AS validTo, revision, created_at AS createdAt`
+
+function rowOf(r: Record<string, unknown>): BindingRow {
+  const profileId = String(r.profileId ?? '')
+  const version = Number(r.profileVersionNumber ?? 1)
+  return {
+    id: String(r.id),
+    workspaceId: String(r.workspaceId),
+    channelId: String(r.channelId),
+    channelAgentId: String(r.channelAgentId),
+    profileId,
+    profileVersionNumber: version,
+    profileVersion: `${profileId}@${version}`,
+    capabilities: JSON.parse(String(r.capabilitiesJson ?? '[]')) as string[],
+    mode: String(r.mode) as BindingMode,
+    validFrom: String(r.validFrom),
+    validTo: r.validTo == null ? null : String(r.validTo),
+    revision: Number(r.revision ?? 1),
+    createdAt: String(r.createdAt),
+  }
+}
+
+export function createBindingRepo(db: DatabaseSync) {
+  return {
+    insert(input: {
+      id: string
+      workspaceId: string
+      channelId: string
+      channelAgentId: string
+      profileId: string
+      profileVersion: number
+      capabilities: string[]
+      mode: BindingMode
+      validFrom?: string
+      validTo?: string | null
+      createdBy?: string
+    }): BindingRow {
+      const now = new Date().toISOString()
+      const validFrom = input.validFrom ?? now
+      try {
+        db.prepare(`INSERT INTO optimizer_bindings
+          (id, workspace_id, channel_id, channel_agent_id, profile_id, profile_version, capabilities_json,
+           mode, valid_from, valid_to, revision, created_by, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`)
+          .run(input.id, input.workspaceId, input.channelId, input.channelAgentId, input.profileId, input.profileVersion,
+            JSON.stringify(input.capabilities), input.mode, validFrom, input.validTo ?? null, input.createdBy ?? '', now, now)
+      }
+      catch (err) {
+        if (String((err as Error).message).includes('UNIQUE')) {
+          throw new AppError(409, 'BINDING_DUPLICATE', '同一 Agent 已绑定该 Profile 版本')
+        }
+        throw err
+      }
+      return this.get(input.id)!
+    },
+
+    get(id: string): BindingRow | undefined {
+      const r = db.prepare(`SELECT ${COLS} FROM optimizer_bindings WHERE id = ?`).get(id) as Record<string, unknown> | undefined
+      return r ? rowOf(r) : undefined
+    },
+
+    listByAgent(channelAgentId: string): BindingRow[] {
+      return (db.prepare(`SELECT ${COLS} FROM optimizer_bindings WHERE channel_agent_id = ? ORDER BY created_at ASC`).all(channelAgentId) as unknown as Record<string, unknown>[]).map(rowOf)
+    },
+
+    listByChannel(channelId: string): BindingRow[] {
+      return (db.prepare(`SELECT ${COLS} FROM optimizer_bindings WHERE channel_id = ? ORDER BY created_at ASC`).all(channelId) as unknown as Record<string, unknown>[]).map(rowOf)
+    },
+
+    listAll(limit = 200): BindingRow[] {
+      return (db.prepare(`SELECT ${COLS} FROM optimizer_bindings ORDER BY created_at DESC LIMIT ?`).all(limit) as unknown as Record<string, unknown>[]).map(rowOf)
+    },
+
+    /** 撤权:删除行(revision 变化由删除时间体现);成员删除由 FK CASCADE 保证。 */
+    remove(id: string): boolean {
+      const r = db.prepare('DELETE FROM optimizer_bindings WHERE id = ?').run(id)
+      return Number(r.changes) > 0
+    },
+
+    bumpRevision(id: string): number {
+      db.prepare('UPDATE optimizer_bindings SET revision = revision + 1, updated_at = ? WHERE id = ?').run(new Date().toISOString(), id)
+      const row = this.get(id)
+      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)
+    },
+  }
+}
+
+export type BindingRepo = ReturnType<typeof createBindingRepo>
+
+const g = globalThis as typeof globalThis & { __optimizerBindingRepo?: BindingRepo }
+
+export function getBindingRepo(): BindingRepo {
+  g.__optimizerBindingRepo ??= createBindingRepo(getAmlRuntime().db)
+  return g.__optimizerBindingRepo
+}