agentworkshop 0.7.66 → 0.7.71

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

@@ -0,0 +1,158 @@
+/* eslint-disable @stylistic/max-statements-per-line */
+/**
+ * OptimizationProfile 仓储:版本化、published 不可变、发布时校验模型/求解器兼容。
+ */
+import type { DatabaseSync } from 'node:sqlite'
+import { AppError } from '../../../utils/errors'
+import { canonicalJson, sha256 } from '../aml/twin/contracts'
+import type { OptimizationProfile, ProfileStatus } from './contracts'
+import { OPTIMIZATION_SCHEMA_VERSION, assertProfileSolverCompatible } from './contracts'
+import { getAmlRuntime } from '../aml/runtime'
+
+export interface ProfileRow {
+  id: string
+  version: number
+  name: string
+  modelRef: string
+  modelArtifactHash: string
+  modelArtifactKind: string
+  modelInterface: string
+  problemTemplateRef: string
+  problemConfigJson: string
+  processSpecRef: string
+  solverRef: string
+  solverVersion: string
+  conditionIdsJson: string
+  status: ProfileStatus
+  ownerUserId: string
+  problemIrHash: string
+  /** 发布不可变校验:内容 hash(不含 status/createdAt/problemIrHash) */
+  contentHash: string
+  createdAt: string
+  updatedAt: string
+}
+
+const COLS = `id, version, name, model_ref AS modelRef, model_artifact_hash AS modelArtifactHash,
+  model_artifact_kind AS modelArtifactKind, model_interface AS modelInterface,
+  problem_template_ref AS problemTemplateRef, problem_config_json AS problemConfigJson,
+  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,
+  created_at AS createdAt, updated_at AS updatedAt`
+
+export function profileContentHash(profile: OptimizationProfile): string {
+  const { createdAt: _createdAt, status: _status, problemIrHash: _irHash, ...stable } = profile as OptimizationProfile
+  return sha256(canonicalJson({ ...stable, schemaVersion: OPTIMIZATION_SCHEMA_VERSION }))
+}
+
+export function createProfileRepo(db: DatabaseSync) {
+  return {
+    insert(profile: OptimizationProfile, ownerUserId = ''): ProfileRow {
+      assertProfileSolverCompatible(profile)
+      const now = new Date().toISOString()
+      const contentHash = profileContentHash(profile)
+      const existing = this.get(profile.id, profile.version)
+      if (existing) {
+        if (existing.contentHash && existing.contentHash !== contentHash) {
+          throw new AppError(409, 'PROFILE_VERSION_IMMUTABLE', `Profile ${profile.id}@${profile.version} 已存在且内容不同;修改必须产生新版本`)
+        }
+        return existing
+      }
+      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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .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)
+      return this.get(profile.id, profile.version)!
+    },
+
+    get(id: string, version?: number): ProfileRow | undefined {
+      const r = version == null
+        ? db.prepare(`SELECT ${COLS} FROM optimizer_profiles WHERE id = ? ORDER BY version DESC LIMIT 1`).get(id)
+        : db.prepare(`SELECT ${COLS} FROM optimizer_profiles WHERE id = ? AND version = ?`).get(id, version)
+      return r as unknown as ProfileRow | undefined
+    },
+
+    list(filter: { status?: string, modelRef?: string, limit?: number } = {}): ProfileRow[] {
+      const where: string[] = []
+      const args: unknown[] = []
+      if (filter.status) { where.push('status = ?'); args.push(filter.status) }
+      if (filter.modelRef) { where.push('model_ref = ?'); args.push(filter.modelRef) }
+      args.push(filter.limit ?? 100)
+      return db.prepare(`SELECT ${COLS} FROM optimizer_profiles ${where.length ? `WHERE ${where.join(' AND ')}` : ''} ORDER BY created_at DESC LIMIT ?`)
+        .all(...(args as never[])) as unknown as ProfileRow[]
+    },
+
+    nextVersion(id: string): number {
+      const r = db.prepare('SELECT MAX(version) AS v FROM optimizer_profiles WHERE id = ?').get(id) as { v: number | null }
+      return (r.v ?? 0) + 1
+    },
+
+    /** 发布:冻结 problemIrHash;published 行禁止原地修改(服务层拒绝 UPDATE)。 */
+    publish(id: string, version: number, problemIrHash?: string): ProfileRow {
+      const row = this.get(id, version)
+      if (!row) throw new AppError(404, 'PROFILE_NOT_FOUND', `Profile ${id}@${version} 不存在`)
+      if (row.status === 'published') return row
+      if (row.status === 'retired') throw new AppError(409, 'PROFILE_RETIRED', `Profile ${id}@${version} 已退役`)
+      const r = db.prepare(`UPDATE optimizer_profiles SET status = 'published', problem_ir_hash = COALESCE(?, problem_ir_hash), updated_at = ?
+        WHERE id = ? AND version = ? AND status IN ('draft','validated')`)
+        .run(problemIrHash ?? null, new Date().toISOString(), id, version)
+      if (Number(r.changes) === 0) throw new AppError(409, 'PROFILE_RACE', 'Profile 状态已被并发修改')
+      return this.get(id, version)!
+    },
+
+    retire(id: string, version: number): ProfileRow {
+      db.prepare(`UPDATE optimizer_profiles SET status = 'retired', updated_at = ? WHERE id = ? AND version = ?`).run(new Date().toISOString(), id, version)
+      const row = this.get(id, version)
+      if (!row) throw new AppError(404, 'PROFILE_NOT_FOUND', `Profile ${id}@${version} 不存在`)
+      return row
+    },
+
+    removeDraft(id: string, version: number): boolean {
+      const row = this.get(id, version)
+      if (!row) return false
+      if (row.status !== 'draft') throw new AppError(409, 'PROFILE_IMMUTABLE', '只有 draft 可删除')
+      db.prepare('DELETE FROM optimizer_profiles WHERE id = ? AND version = ?').run(id, version)
+      return true
+    },
+  }
+}
+
+export type ProfileRepo = ReturnType<typeof createProfileRepo>
+
+const g = globalThis as typeof globalThis & { __optimizerProfileRepo?: ProfileRepo }
+
+export function getProfileRepo(): ProfileRepo {
+  g.__optimizerProfileRepo ??= createProfileRepo(getAmlRuntime().db)
+  return g.__optimizerProfileRepo
+}
+
+export function parseProfileRow(row: ProfileRow): OptimizationProfile {
+  return {
+    schemaVersion: OPTIMIZATION_SCHEMA_VERSION,
+    id: row.id,
+    version: row.version,
+    name: row.name,
+    modelRef: {
+      modelId: row.modelRef,
+      artifactHash: row.modelArtifactHash,
+      artifactKind: row.modelArtifactKind as OptimizationProfile['modelRef']['artifactKind'],
+      modelInterface: row.modelInterface as OptimizationProfile['modelRef']['modelInterface'],
+      stage: 'candidate',
+    },
+    problemTemplateRef: row.problemTemplateRef as OptimizationProfile['problemTemplateRef'],
+    problemConfig: JSON.parse(row.problemConfigJson || '{}') as OptimizationProfile['problemConfig'],
+    processSpecRef: row.processSpecRef,
+    solverRef: row.solverRef as OptimizationProfile['solverRef'],
+    solverVersion: row.solverVersion,
+    conditionIds: JSON.parse(row.conditionIdsJson || '[]') as string[],
+    status: row.status,
+    ownerUserId: row.ownerUserId,
+    problemIrHash: row.problemIrHash || undefined,
+    createdAt: row.createdAt,
+  }
+}

package/server/services/workshop/optimization/python/.mimosa/hook-state/session_187ec97f45d4bd02369bbe94da527cf1.json

@@ -0,0 +1 @@
+{"touched":["C:\\Users\\87287\\AppData\\Local\\Temp\\prob-debug.py","D:\\codes\\ABO\\AgentWorkShop\\server\\services\\workshop\\optimization\\python\\problems.py"],"bashMutation":false,"reportedFindings":[],"findingEvents":[],"baseline":{"storageId":"mvjqkcs6-68688-fb7131a89c","createdAt":"2026-10-22T16:08:59.574Z","files":{"C:/Users/87287/AppData/Local/Temp/prob-debug.py":{"existed":false},"problems.py":{"existed":true,"snapshot":"190a6772a4e43801737b4ba6072eb9d53d3099b5d8a9e6f57bc5e8592a26a6c4.source"}},"complete":false,"candidateLimit":5000,"discoveredFiles":0,"capturedFiles":2,"truncated":false,"omittedAtLeast":0,"firstOmitted":"","errors":[{"stage":"baseline-capture","target":".","reason":"global task baseline was unavailable; captured only the touched file"},{"stage":"baseline-snapshot","target":"../../../../../tests/optimizer-contracts.test.ts","reason":"file is outside project"},{"stage":"baseline-snapshot","target":"../../../../../tests/process-model-trainers.test.ts","reason":"file is outside project"}]},"stateErrors":[],"omittedReportedFindings":0,"omittedFindingEvents":0,"processing":null,"updatedAt":"2026-10-22T16:09:19.251Z"}

package/server/services/workshop/optimization/python/.mimosa/hook-state/session_187ec97f45d4bd02369bbe94da527cf1.mvjqkcs6-68688-fb7131a89c.baseline/190a6772a4e43801737b4ba6072eb9d53d3099b5d8a9e6f57bc5e8592a26a6c4.source

@@ -0,0 +1,274 @@
+"""
+ProblemIR 编译/求解的数值实现(与 TS problem-builder 的离散语义逐项对齐)。
+
+- 线性 MPC:y_t = o_t + S_t·u(对 Δu 的稠密二次型),交给 OSQP;
+- 稳态响应面:经济代价 + CV 跟踪,SciPy SLSQP 有界约束优化。
+"""
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+
+
+def _as_matrix(flat: list[float], rows: int, cols: int) -> np.ndarray:
+    return np.asarray(flat, dtype=float).reshape((rows, cols))
+
+
+class LinearMpcProblem:
+    def __init__(self, ir: dict[str, Any]):
+        problem = ir["problem"]
+        dyn = problem["dynamics"]
+        self.state_dim = int(dyn["stateDim"])
+        self.mv_order = list(problem["mvOrder"])
+        self.cv_order = list(problem["cvOrder"])
+        self.mv_count = len(self.mv_order)
+        self.cv_count = len(self.cv_order)
+        self.horizon = int(ir["horizon"])
+        self.A = _as_matrix(dyn["A"], self.state_dim, self.state_dim)
+        self.B = _as_matrix(dyn["B"], self.state_dim, self.mv_count)
+        self.C = _as_matrix(dyn["C"], self.cv_count, self.state_dim)
+        self.D = _as_matrix(dyn["D"], self.cv_count, self.mv_count)
+        self.x0 = np.asarray(dyn["x0"], dtype=float)
+        self.u_prev = np.asarray(problem["uPrev"], dtype=float)
+        self.cv_setpoints = np.asarray(problem["cvSetpoints"], dtype=float)
+        weights = ir["weights"]
+        self.q = np.asarray([float(weights["cv"].get(cv, 1.0)) for cv in self.cv_order], dtype=float)
+        self.r = np.asarray([float(weights["du"].get(mv, 0.0)) for mv in self.mv_order], dtype=float)
+        self.terminal = float(weights.get("terminal") or 0.0)
+        self.mv_bounds = problem["mvBounds"]
+        self.cv_bounds = problem.get("cvBounds") or [{} for _ in self.cv_order]
+        self.sensitivity: list[np.ndarray] = []
+        self.offset: list[np.ndarray] = []
+        self._build_sensitivity()
+
+    def _build_sensitivity(self) -> None:
+        """y_t = offset_t + S_t·u,t=1..H(u 为 H 步 MV 序列)。"""
+        hm = self.horizon * self.mv_count
+        x_affine_A = np.zeros((self.state_dim, self.state_dim))
+        x_affine_b = np.zeros(self.state_dim)
+        # x_0 = x0(与 u 无关);逐步展开:x_t = A^t x0 + Σ_{s<t} A^{t-1-s} B u_s
+        powers = [np.eye(self.state_dim)]
+        for _ in range(self.horizon):
+            powers.append(powers[-1] @ self.A)
+        for t in range(1, self.horizon + 1):
+            off = powers[t] @ self.x0
+            sens = np.zeros((self.cv_count, hm))
+            for s in range(t):
+                block = powers[t - 1 - s] @ self.B  # state effect of u_s
+                yblock = self.C @ block  # cv effect
+                for m in range(self.mv_count):
+                    sens[:, s * self.mv_count + m] += yblock[:, m]
+            self.sensitivity.append(sens)
+            self.offset.append(self.C @ off)
+        # 当前 y_0(用于 D 直通不参与;MPC 首步输出在 t=1)
+        del x_affine_A, x_affine_b
+
+    def qp(self) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        hm = self.horizon * self.mv_count
+        P = np.zeros((hm, hm))
+        q = np.zeros(hm)
+        for t, (sens, off) in enumerate(zip(self.sensitivity, self.offset)):
+            w = self.q if t < self.horizon - 1 else self.q * (1.0 + self.terminal)
+            P += 2.0 * (sens.T @ (w[:, None] * sens))
+            q += 2.0 * (sens.T @ (w * (off - self.cv_setpoints)))
+        # Δu 惩罚
+        for m in range(self.mv_count):
+            if self.r[m] <= 0:
+                continue
+            for t in range(self.horizon):
+                idx = t * self.mv_count + m
+                prev_idx = (t - 1) * self.mv_count + m if t > 0 else None
+                P[idx, idx] += 2.0 * self.r[m]
+                if prev_idx is not None:
+                    P[idx, idx] += 2.0 * self.r[m]
+                    P[idx, prev_idx] -= 2.0 * self.r[m]
+                    P[prev_idx, idx] -= 2.0 * self.r[m]
+                    P[prev_idx, prev_idx] += 2.0 * self.r[m]
+                else:
+                    # t=0:Δu = u0 - u_prev → 常数项进入 q
+                    q[idx] += -2.0 * self.r[m] * self.u_prev[m]
+                    P[idx, idx] += 2.0 * self.r[m]
+        # 对称化
+        P = 0.5 * (P + P.T)
+        # 约束:l <= Az <= u(变量边界 + 速率)
+        rows = []
+        lows = []
+        highs = []
+        for t in range(self.horizon):
+            for m in range(self.mv_count):
+                idx = t * self.mv_count + m
+                row = np.zeros(hm)
+                row[idx] = 1.0
+                rows.append(row)
+                bounds = self.mv_bounds[m]
+                lows.append(float(bounds.get("min", -np.inf)))
+                highs.append(float(bounds.get("max", np.inf)))
+                max_step = bounds.get("maxStep")
+                if max_step is not None:
+                    row2 = np.zeros(hm)
+                    row2[idx] = 1.0
+                    prev = self.u_prev[m] if t == 0 else None
+                    if prev is not None:
+                        lows.append(-float(max_step) + prev)
+                        highs.append(float(max_step) + prev)
+                    else:
+                        row2[(t - 1) * self.mv_count + m] = -1.0
+                        lows.append(-float(max_step))
+                        highs.append(float(max_step))
+                    rows.append(row2)
+        # CV 有效域(软约束之外硬边界;首版按硬约束处理)
+        for t in range(self.horizon):
+            for j in range(self.cv_count):
+                bounds = self.cv_bounds[j] or {}
+                lo = bounds.get("min")
+                hi = bounds.get("max")
+                if lo is None and hi is None:
+                    continue
+                row = np.zeros(hm)
+                sens = self.sensitivity[t][j]
+                row += sens
+                rows.append(row)
+                lows.append(float(lo) - float(self.offset[t][j]) if lo is not None else -np.inf)
+                highs.append(float(hi) - float(self.offset[t][j]) if hi is not None else np.inf)
+        A = np.vstack(rows) if rows else np.zeros((0, hm))
+        return P, q, A, np.asarray(lows), np.asarray(highs)
+
+
+def solve_linear_mpc(ir: dict[str, Any], cancel_check, max_chunk_iters: int = 400) -> dict[str, Any]:
+    import osqp  # type: ignore
+    import scipy.sparse as sp  # type: ignore
+
+    prob = LinearMpcProblem(ir)
+    P, q, A, low, high = prob.qp()
+    solver = osqp.OSQP()
+    solver.setup(
+        P=sp.csc_matrix(P), q=q, A=sp.csc_matrix(A), l=low, u=high,
+        verbose=False, polish=True, max_iter=max_chunk_iters,
+        eps_abs=1e-8, eps_rel=1e-8,
+    )
+    result = solver.solve()
+    rounds = 0
+    while result.info.status_val in (1, 3) and rounds < 20:  # 1=unsolved, 3=max_iter
+        if cancel_check():
+            return {"status": "cancelled", "message": "cancelled during iterations"}
+        rounds += 1
+        result = solver.solve()
+    status = str(result.info.status)
+    if "solved" not in status or result.x is None:
+        return {
+            "status": "infeasible" if "infeasible" in status else "numerical_error",
+            "message": status,
+            "iterations": int(getattr(result.info, "iter", 0)),
+        }
+    z = np.asarray(result.x, dtype=float).reshape((prob.horizon, prob.mv_count))
+    predicted = []
+    for sens, off in zip(prob.sensitivity, prob.offset):
+        predicted.append(off + sens @ z.reshape(-1))
+    cost = float(0.5 * z.reshape(-1) @ P @ z.reshape(-1) + q @ z.reshape(-1))
+    return {
+        "status": "optimal" if "polished" in status or "solved" in status else "feasible",
+        "controls": z.tolist(),
+        "predicted": [row.tolist() for row in predicted],
+        "cost": cost,
+        "iterations": int(getattr(result.info, "iter", 0)),
+        "backend": "osqp",
+        "solverVersion": getattr(osqp, "__version__", "unknown"),
+    }
+
+
+def solve_steady_response(ir: dict[str, Any], cancel_check) -> dict[str, Any]:
+    from scipy.optimize import minimize  # type: ignore
+
+    problem = ir["problem"]
+    mv_order = list(problem["mvOrder"])
+    cv_order = list(problem["cvOrder"])
+    feature_order = list(problem["featureOrder"])
+    coefficients = problem["coefficients"]
+    targets = np.asarray(problem["cvTargets"], dtype=float)
+    weights = ir["weights"]
+    economic = weights.get("economic") or {}
+    cv_weights = weights.get("cv") or {}
+    mv_bounds = problem["mvBounds"]
+    cv_bounds = problem.get("cvBounds") or [{} for _ in cv_order]
+    x0 = np.asarray(problem["uPrev"], dtype=float)
+    lo = np.asarray([float(b.get("min", -1e9)) for b in mv_bounds])
+    hi = np.asarray([float(b.get("max", 1e9)) for b in mv_bounds])
+
+    def features(u: np.ndarray) -> np.ndarray:
+        by_name = {name: float(u[i]) for i, name in enumerate(mv_order)}
+        out = []
+        for name in feature_order:
+            if name == "bias":
+                out.append(1.0)
+            elif name.endswith("^2"):
+                out.append(by_name.get(name[:-2], 0.0) ** 2)
+            elif "*" in name:
+                a, b = name.split("*", 1)
+                out.append(by_name.get(a, 0.0) * by_name.get(b, 0.0))
+            else:
+                out.append(by_name.get(name, 0.0))
+        return np.asarray(out)
+
+    def objective(u: np.ndarray) -> float:
+        cost = 0.0
+        for i, name in enumerate(mv_order):
+            cost += float(economic.get(name, 0.0)) * float(u[i])
+        feat = features(u)
+        for j, cv in enumerate(cv_order):
+            coef = np.asarray(coefficients[cv], dtype=float)
+            y = float(coef @ feat)
+            cost += float(cv_weights.get(cv, 0.0)) * (y - float(targets[j])) ** 2
+        return cost
+
+    def constraints():
+        cons = []
+        for j, cv in enumerate(cv_order):
+            bounds = cv_bounds[j] or {}
+            if bounds.get("min") is None and bounds.get("max") is None:
+                continue
+            coef = np.asarray(coefficients[cv], dtype=float)
+            def make(j=j, coef=coef, bounds=bounds):
+                def f(u: np.ndarray) -> float:
+                    return float(coef @ features(u))
+                return f
+            f = make()
+            if bounds.get("min") is not None:
+                cons.append({"type": "ineq", "fun": lambda u, f=f, lo=float(bounds["min"]): f(u) - lo})
+            if bounds.get("max") is not None:
+                cons.append({"type": "ineq", "fun": lambda u, f=f, hi=float(bounds["max"]): hi - f(u)})
+        return cons
+
+    if cancel_check():
+        return {"status": "cancelled", "message": "cancelled before solve"}
+    result = minimize(
+        objective, x0, method="SLSQP", bounds=list(zip(lo, hi)), constraints=constraints(),
+        options={"maxiter": 500, "ftol": 1e-10},
+    )
+    if not result.success:
+        return {"status": "infeasible", "message": str(result.message), "iterations": int(result.nit)}
+    controls = np.asarray(result.x, dtype=float)
+    feat = features(controls)
+    predicted = [float(np.asarray(coefficients[cv], dtype=float) @ feat) for cv in cv_order]
+    return {
+        "status": "optimal",
+        "controls": [controls.tolist()],
+        "predicted": [predicted],
+        "cost": float(result.fun),
+        "iterations": int(result.nit),
+        "backend": "scipy",
+        "solverVersion": "scipy",
+    }
+
+
+def check_finite(payload: Any) -> bool:
+    def walk(value: Any) -> bool:
+        if isinstance(value, float):
+            return math.isfinite(value)
+        if isinstance(value, list):
+            return all(walk(v) for v in value)
+        if isinstance(value, dict):
+            return all(walk(v) for v in value.values())
+        return True
+    return walk(payload)

package/server/services/workshop/optimization/python/.mimosa/hook-status/session_187ec97f45d4bd02369bbe94da527cf1-01ed7f04fa.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": "mimosa-hook-status/v1",
+  "recordedAt": "2026-10-22T16:09:21.007Z",
+  "sessionId": "session_187ec97f45d4bd02369bbe94da527cf1",
+  "event": "PostToolUse",
+  "toolName": "Edit",
+  "file": "D:/codes/ABO/AgentWorkShop/tests/process-model-trainers.test.ts",
+  "outcome": "inconclusive",
+  "coverage": "partial",
+  "findingCount": 0,
+  "durationMs": 9,
+  "hostState": "hook_complete",
+  "reportHint": ".mimosa/reports/"
+}

package/server/services/workshop/optimization/python/probe.py

@@ -0,0 +1,24 @@
+"""能力探针:解释器/依赖可用性(不抛异常;退出码 0 = 全部可用)。"""
+import json
+import sys
+
+result = {"python": sys.version.split()[0], "osqp": None, "scipy": None, "numpy": None}
+try:
+    import numpy  # type: ignore
+    result["numpy"] = numpy.__version__
+except Exception:
+    pass
+try:
+    import scipy  # type: ignore
+    result["scipy"] = scipy.__version__
+except Exception:
+    pass
+try:
+    import osqp  # type: ignore
+    result["osqp"] = osqp.__version__
+except Exception:
+    pass
+
+sys.stdout.write(json.dumps(result) + "\n")
+ok = result["scipy"] is not None and result["osqp"] is not None and result["numpy"] is not None
+sys.exit(0 if ok else 3)