docs：ARCHITECTURE / ROADMAP 同步 D17 Human-in-Loop 完成

更新两个权威文档与 D17 端到端闭环对齐： - docs/ROADMAP.md §2.2 主线二"moldinsight 工程化增强"重点方向加一条 D17 已完成条目（2026-09-23~24，3 个 commit：数据 + 权限 + 写入 API / 算法接缝 + OCC payload / 前端按钮 + Dialog + 经验角标；详见 TECH_DEBT.md D17），与既有 ~~XXX~~（YYYY-MM-DD 完成）格式一致 - docs/ARCHITECTURE.md 新增 §6.4 D17 Human-in-Loop 老师傅经验反馈闭环 —— 已完成段：用 ASCII 数据流图展示老师傅点反馈按钮 → 路由层 → service 写入 → 续期衰减 → 上传新 STP 触发 resolve_for_process_params → OCC payload 透传 → planner 算法加成 → ResultView 渲染的端到端链路段内列出"硬规则遵守"（跨模块 FK 守 §5.1、OCC payload 守 occ_worker.py:7-8、D9 边界不破、init_db.py 幂等修复已落）和 "重量级约束"（weight 仅正向、sample_count<2 时 ×0.5、graceful 退化、角色门控），最后给测试基线指针放在 §6.3"文档与结构尚未完全同步"之后作为"已完成端到端闭环" 对照示例，便于新成员理解 D17 在系统中的位置文档侧仅变更，无代码改动；按 AGENTS.md §4.1 映射表，模块边界（ARCHITECTURE.md）/ 演进路线（ROADMAP.md）相关变更同步。 Co-Authored-By: Claude Code <noreply@anthropic.com>
D17 批 3：前端按钮 + Dialog + 经验角标——闭环可视
2026-09-24 10:15:36 +08:00 · 2026-09-24 10:03:09 +08:00 · 2026-09-23 16:21:33 +08:00 · 2026-09-23 16:11:17 +08:00 · 2026-09-23 09:59:02 +08:00
36 changed files with 3417 additions and 2220 deletions
@@ -28,6 +28,7 @@
 - **单数据库是刻意设计**：moldinsight 与 inventory 共享同一 PostgreSQL（如 `STPFile.product_id -> Product.id` 桥接），不拆库。
 - **接口变更三件套**：优先用 Pydantic 请求模型（少用手写 `request.json()` 解析）→ 重新导出根目录 `openapi.json` → 前端 `npm run gen:api` 重新生成类型。三步缺一即契约漂移。
 - **历史材料统一进 [docs/archive/](docs/archive/README.md)**，不与当前权威文档混放。
+- **历史批次详细流水账 / 早段 STATUS**：见 [docs/archive/2026-09_governance_batches.md](docs/archive/2026-09_governance_batches.md) 与 [docs/archive/2026-09_status_history.md](docs/archive/2026-09_status_history.md)；主骨架权威文档（TECH_DEBT §2 / STATUS 顶部）只保留摘要。
 - **配置只走 `.env`**（参照 [.env.example](.env.example) 全键说明）：`DB_*`、`SECRET_KEY` 等关键项不设代码兜底（惰性校验，缺失即报），不在代码里给 localhost/弱口令默认值。

 ## 3. 代码地图
@@ -120,7 +121,7 @@ frontend/                       # Vue 3 独立工程：src/modules 按域组织
 migrations/                     # 数据库迁移
 scripts/                        # 一次性迁移与工具脚本（migrations/ 数据迁移、db/ 索引与审计 SQL、tools/ 检查工具），非运行时代码
 tests/                          # pytest：sqlite+aiosqlite 临时库；pythonocc 缺失时 OCC 契约测试自动 skip
-deploy/                         # Dockerfile.* / nginx / build 脚本
+deploy/                         # Dockerfile.* / nginx / build 脚本 / generate_lockfiles.{sh,bat}（D13 锁文件生成入口）
 docs/                           # 权威文档（本文件 §5 导航）
 ```

@@ -4,8 +4,10 @@
 # conda 运行时作为最终镜像的执行环境，自带全部动态库。
 FROM continuumio/miniconda3:24.7.1-0

-# 锁定几何栈核心版本；pip 侧全量版本锁待首次镜像构建成功后由
-# `pip freeze > deploy/requirements-moldinsight.lock.txt` 生成（D13 遗留项）
+# 锁定几何栈核心版本；pip 侧全量版本锁由
+# `bash deploy/generate_lockfiles.sh` 在 moldinsight conda 环境内执行后生成
+# （D13，参见 deploy/generate_lockfiles.sh / .bat 与 docs/OPERATIONS.md §2）
+# 落盘产物为 deploy/requirements-{base,moldinsight}.lock.txt，CI / 离线构建可直接锁定安装
 RUN conda create -n moldinsight -c conda-forge -y \
        python=3.12 \
        pythonocc-core=7.9.0 \
@@ -0,0 +1,38 @@
+@echo off
+REM ============================================================
+REM geMoldInsight pip 锁文件生成脚本（TECH_DEBT D13，Windows 版）
+REM ============================================================
+REM
+REM 用法：在 gemold conda 环境内执行 deploy\generate_lockfiles.bat
+REM
+REM 产物：
+REM   deploy\requirements-base.lock.txt
+REM   deploy\requirements-moldinsight.lock.txt
+REM ============================================================
+
+setlocal enabledelayedexpansion
+cd /d "%~dp0\.."
+
+where conda >nul 2>&1
+if errorlevel 1 (
+    echo [ERROR] conda 未安装或不在 PATH，请先激活 conda 环境 ^(推荐 moldinsight^) 1>&2
+    exit /b 1
+)
+
+if not "%CONDA_DEFAULT_ENV%"=="moldinsight" if not "%CONDA_DEFAULT_ENV%"=="gemold" (
+    echo [WARN] 当前 conda 环境为 '%CONDA_DEFAULT_ENV%'，推荐在 'moldinsight' 内执行
+)
+
+echo ==^> 生成 base 锁文件
+pip freeze --exclude pythonocc-core > deploy\requirements-base.lock.txt
+
+echo ==^> 生成 moldinsight 锁文件
+pip freeze --exclude pythonocc-core > deploy\requirements-moldinsight.lock.txt
+
+echo.
+echo 已生成：
+echo   deploy\requirements-base.lock.txt
+echo   deploy\requirements-moldinsight.lock.txt
+echo.
+echo 下一步：提交两个 lock.txt，并按团队策略同步更新 requirements-*.txt 下限。
+endlocal
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# ============================================================
+# geMoldInsight pip 锁文件生成脚本（TECH_DEBT D13）
+# ============================================================
+#
+# 设计要点：
+# - 锁文件必须在构建产出的 conda/minimal 环境里生成（只有 geMoldInsight 依赖 + 基础库），
+#   本机开发环境的 `pip freeze` 会污染（全开发栈混装），不能直接落锁。
+# - 仅在带 moldinsight 的 conda 环境内运行 `pip freeze > deploy/requirements-<x>.lock.txt`
+#   才有意义。
+# - 锁文件落盘后即可被 CI / 离线构建 / 复现部署直接 `pip install -r` 锁定版本，
+#   而不再依赖 >= 下限解析。
+#
+# 用法（必须在 `gemold` conda 环境内执行）：
+#   bash deploy/generate_lockfiles.sh
+#
+# 产物：
+#   deploy/requirements-base.lock.txt
+#   deploy/requirements-moldinsight.lock.txt
+# ============================================================
+
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+if ! command -v conda >/dev/null 2>&1; then
+    echo "[ERROR] conda 未安装或不在 PATH，请先激活 conda 环境（推荐环境名 moldinsight）" >&2
+    exit 1
+fi
+
+if [[ "${CONDA_DEFAULT_ENV:-}" != "moldinsight" && "${CONDA_DEFAULT_ENV:-}" != "gemold" ]]; then
+    echo "[WARN] 当前 conda 环境为 '${CONDA_DEFAULT_ENV:-<未激活>}'，" \
+         "推荐在 'moldinsight' conda 环境内运行（否则锁文件将含宿主污染）" >&2
+fi
+
+echo "==> 生成 base 锁文件"
+pip freeze --exclude pythonocc-core > deploy/requirements-base.lock.txt
+
+echo "==> 生成 moldinsight 锁文件"
+pip freeze --exclude pythonocc-core > deploy/requirements-moldinsight.lock.txt
+
+echo
+echo "已生成："
+echo "  deploy/requirements-base.lock.txt           ($(wc -l < deploy/requirements-base.lock.txt) 行)"
+echo "  deploy/requirements-moldinsight.lock.txt    ($(wc -l < deploy/requirements-moldinsight.lock.txt) 行)"
+echo
+echo "下一步："
+echo "  1. 提交这两个 lock.txt（仅含项目直接依赖 + conda-minimal 环境产出）"
+echo "  2. 同步更新 deploy/requirements-base.txt / requirements-moldinsight.txt 的版本下限" \
+     "为 lock 中的实际版本（或保留 >=，按团队策略）"
@@ -54,6 +54,7 @@
 | 加工 | `/api/design-cam`、`/api/check-collision`、`/api/optimize-toolpath`、`/api/design-electrodes`、`/api/simulate-machining` | machining_router.py |
 | 导出 | `/api/export-mold`、`/api/export-download/{filepath}`、`/api/export-recommendations` | export_router.py |
 | 铝价（模拟数据） | `/api/aluminum-price/current`、`/api/aluminum-price/history` | aluminum_price_routes.py |
+| 老师傅经验反馈（D17） | `/api/tasks/{task_id}/experience-feedback`（写入：需登录 + 任务归属 + `feedback_experience_hint` 权限；body 含 `scheme_id` / `feedback_status ∈ {adopted, adjust, rejected}` / 可选 `feedback_reason` / `adjust_suggestion` / 上下文快照；写完调用 `TaskQueryService.invalidate_task_view`）；`/api/tasks/{task_id}/experience-hints`（读取：需登录 + 任务归属；返回同 stp_file_id + material_family + is_foam 锚定的历史 hints 聚合，按 scheme_axis 分组，含 adopted/rejected/adjust 计数 + 加权 confidence + sample_count + 回显 fingerprint） | experience_feedback_router.py |
 | 健康检查 | `/api/health`（有路由装载失败时 `status: degraded` 并列出失败清单；`pythonocc` 为真实探测） | health_router.py |
 | 调试（仅 DEBUG） | `/api/debug/tasks` | debug_router.py |

@@ -205,6 +205,84 @@ geMoldInsight/

 代码结构已明显模块化，但历史文档中仍保留不少阶段性叙述、旧部署语义与重复说明，这也是本轮文档整理要解决的问题之一。

+### 6.4 D17 Human-in-Loop 老师傅经验反馈闭环 —— 已完成（2026-09-23~24，3 个 commit）
+
+算法演进由老师傅经验驱动：通过方案级整体反馈（采纳 / 建议调整 / 拒绝）按"产品指纹 + 工艺参数"为键跨任务匹配，下次同指纹产品分析自动消费老师傅沉淀的经验。这是少数"算法层由用户在线学习样本持续校准"的端到端闭环。
+
+**端到端数据流**：
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  老师傅在 ResultView 点 👍 老师傅反馈按钮                      │
+│     → HumanFeedbackDialog 三选一（采纳 / 建议调整 / 拒绝）     │
+└──────────────────────────────┬──────────────────────────────┘
+                               │ POST /api/tasks/{id}/experience-feedback
+                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│  experience_feedback_router (src/moldinsight/api/)             │
+│    - ensure_task_access 归属校验                              │
+│    - current_user.has_permission("feedback_experience_hint")  │
+│    - service.record_feedback (flush; commit + invalidate)    │
+└──────────────────────────────┬───────────────────────────────┘
+                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│  experience_feedback_service.record_feedback                  │
+│    - compute_fingerprint (bbox_aspect / volume_bucket /       │
+│      face_bucket / undercut_class / material_family / is_foam) │
+│    - 写 experience_feedback 表（D9 边界 / D17 衰减 90d TTL）  │
+│    - 同 stp_file_id 整体续期 expires_at                       │
+└──────────────────────────────┬───────────────────────────────┘
+                               │  同 stp_file_id 上传新 STP 自动消费
+                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│  processing_service._step_generate_cavity                     │
+│    - experience_feedback_service.resolve_for_process_params   │
+│      → hints (List[{scheme_axis, weight, sample_count, ...}]) │
+│    - hints 装进 run_occ payload 顶层 experience_hints          │
+└──────────────────────────────┬───────────────────────────────┘
+                               │  OCC 子进程（spawn 隔离）
+                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│  occ_worker._op_generate_cavity                               │
+│    - payload.get("experience_hints") or {} → planner.generate_plan(hints=...) │
+└──────────────────────────────┬───────────────────────────────┘
+                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│  MultiSchemeMoldPlanner.generate_plan(..., hints=None)        │
+│    - candidate_generator.generate_candidates(..., hints)      │
+│        * priority_score += weight × 20                        │
+│        * sample_count ≥ 2 + weight ≥ 0.5 → method="human_experience_primary" │
+│    - scheme_scorer.score_schemes(schemes, *, hints)            │
+│        * score_breakdown["human_hint_bonus"] = weight × 12    │
+│          （sample_count < 2 时 ×0.5 折半）                    │
+│    - global_summary.applied_hints 注入返回                   │
+└──────────────────────────────┬───────────────────────────────┘
+                               ▼
+┌──────────────────────────────────────────────────────────────┐
+│  ResultView 渲染：                                            │
+│    - summary-header 加 t-tag theme="success" 📚 历史经验 N 条  │
+│    - 反馈提交后 onFeedbackSubmitted → loadExperienceHints 即刷  │
+└──────────────────────────────────────────────────────────────┘
+```
+
+**硬规则遵守**：
+
+- 跨模块 FK 仍守 §5.1（`experience_feedback.user_id` / `processing_task_id` / `stp_file_id` 全用字符串表名，无 ORM relationship）
+- OCC 跨进程守 [occ_worker.py:7-8](../src/moldinsight/core/occ_worker.py#L7-L8) "杜绝 pickle OCC 对象"——payload 普通 dict 透传
+- D9 边界不破：service.flush + 路由 commit（无 service 内 commit）
+- 现有 `init_db.py` 幂等修复：按 code 补登权限/角色
+
+**重量级约束**：
+
+- `weight = max(0, (adopted-rejected)/total)`：仅正向有效，老师傅拒绝不"扣分"老算法
+- `sample_count < 2` 时 bonus ×0.5：信号不足折半，但 priority_score 仍加成（候选方向仍偏向）
+- 解析失败回退空 list：graceful，主流程不因下游错误退化
+- `canGiveFeedback` 角色门控：`is_superuser || roles 含 process_engineer`
+
+**测试基线**：192 passed, 13 skipped（批 3 净增 +4 OCC-gated：candidate_generator 3 / scheme_scorer 4 / multi_scheme_planner 2 / processing_service 2）；前端 vue-tsc + vite 通过。
+
+详见 [TECH_DEBT.md](TECH_DEBT.md) D17 + [STATUS.md](STATUS.md) 2026-09-23~24 日志。
+
 ---

 ## 7. 专题文档与主骨架的关系
@@ -26,10 +26,24 @@
 ## 2. 安装与环境

 - 后端依赖：`pip install -r requirements.txt`。
- **OCC 几何能力**：PythonOCC 不走 pip 主路径，通过 conda 环境提供（本项目实践环境名 `gemold`）。无 OCC 环境时项目可启动，但几何分析契约测试自动 skip。
+- **OCC 几何能力**：PythonOCC 不走 pip 主路径，通过 conda 环境提供（本项目实践环境名 `gemold` 或 `moldinsight`）。无 OCC 环境时项目可启动，但几何分析契约测试自动 skip。
 - 前端：`cd frontend && npm install`。
 - 数据库迁移：`migrations/`（`alembic.ini` 在仓库根；2026-09-16 由 `alembic/` 改名——原目录名与 alembic 包重名，应用内 import 会被遮蔽导致启动期迁移静默失败）；数据修复类一次性脚本在 `scripts/migrations/` 与 `scripts/db/`，**不是运行时代码**，勿在服务内引用。

+### 2.1 pip 锁文件生成（D13 流程）
+
+`deploy/requirements-{base,moldinsight}.lock.txt` 是项目依赖的**版本锁**，由 conda 环境首次构建成功后一次性落盘：
+
+- **生成时机**：在 `moldinsight` / `gemold` conda 环境（仅含项目依赖 + conda 基础库，**不能**在混装全开发栈的本机 pip 环境跑）执行 `pip freeze`
+- **生成命令**：
+  - Linux / macOS：`bash deploy/generate_lockfiles.sh`
+  - Windows：`deploy\generate_lockfiles.bat`
+- **产物**：
+  - `deploy/requirements-base.lock.txt`
+  - `deploy/requirements-moldinsight.lock.txt`
+- **消费方**：CI、离线构建、生产复现部署；`pip install -r deploy/requirements-base.lock.txt` 可直接锁定安装而不依赖 `>=` 解析
+- **提交策略**：两个 lock.txt 提交到仓库；版本下限（`requirements-{base,moldinsight}.txt`）按团队策略同步或保留 `>=` 灵活解析
+
 ## 3. 本地启动

 后端三入口（均含 sys.path 修正，可从仓库根直接跑）：
@@ -46,6 +46,7 @@ geMoldInsight 已从历史单体逐步演进为“双业务模块 + 共享平台
 重点方向：

 - ~~`advanced_router` 拆分与请求模型规范化~~（2026-09-17 批次 3 完成）
+- ~~D17 Human-in-Loop 老师傅经验反馈~~（2026-09-23~24 完成，3 个 commit：数据 + 权限 + 写入 API / 算法接缝 + OCC payload / 前端按钮 + Dialog + 经验角标；写入即消费闭环通；详见 [TECH_DEBT.md](TECH_DEBT.md) D17）
 - 模具分析链路的结构继续收口
 - OCC 依赖场景下的契约测试/集成测试继续补齐

@@ -2,9 +2,20 @@

 > 文档定位：**唯一的「现在到哪了」**。README / AGENTS / 各主文档只链接到这里，不复制状态内容。
 > 维护规则：每完整完成一个需求，**倒序在本文顶部加一条**（日期 + 主题 + 关键事实）；其余主文档（架构 / 规划 / 技术债 / 部署）维护各自的"当前有效说法"，本文只记录"什么时候做到了哪一步"。维护规则出处见根目录 [AGENTS.md](../AGENTS.md)。
+> 早期条目（2026-09-17 之前）已精简为锚点，完整流水见 [archive/2026-09_governance_batches.md](archive/2026-09_governance_batches.md) 与 [archive/2026-09_status_history.md](archive/2026-09_status_history.md)。
+
+> 2026-09-24（**D17 Human-in-Loop 老师傅经验反馈批 3 上线（前端按钮 + Dialog + 经验角标）——闭环可视**：① [ResultView.vue:35-47](frontend/src/modules/moldinsight/ResultView.vue#L35-L47) 方案卡片 summary-header 加 `t-tag theme="success" variant="light"` 经验角标（"📚 历史经验 N 条"），从 `hintsByAxis[currentAxisHint]` 读取，按 scheme_axis 索引，无 hints 时不渲染；② [ResultView.vue:131-138](frontend/src/modules/moldinsight/ResultView.vue#L131-L138) `export-buttons-bar` 加 `👍 老师傅反馈` 按钮（`v-if="canGiveFeedback"` 角色门控：admin 或 process_engineer）；③ 新建 [components/HumanFeedbackDialog.vue](frontend/src/modules/moldinsight/components/HumanFeedbackDialog.vue)：t-dialog + t-form + t-radio-group 三选一（采纳 / 建议调整 / 拒绝）+ t-textarea 原因 + 调整建议（仅 adjust 模式显隐）；提交走 `moldinsightApi.submitExperienceFeedback`，成功后 emit `submitted` 让父组件重拉 hints 刷新角标；④ [shared/api-client.ts:407-444](frontend/src/shared/api-client.ts#L407-L444) `moldinsightApi` 新增 `getExperienceHints` / `submitExperienceFeedback` 两个方法（生成类型由 openapi-typescript 自动产出）；⑤ [ResultView.vue](frontend/src/modules/moldinsight/ResultView.vue) `onMounted` 调 `loadExperienceHints` 拉一次 + 反馈提交后 `onFeedbackSubmitted` 再拉一次（写入即消费前端可见）；`canGiveFeedback` 走 `is_superuser || roles 含 process_engineer` 表达式（项目硬规则"前端不要破坏 ResultView.vue 视觉一致性"：按钮与既有 6 个 t-button 同一 `export-buttons-bar`，theme/size 一致；角标 theme="success" variant="light" 与既有 t-tag theme="primary" / "warning" 同款）。**接口变更三件套随批完成**：openapi.json 重导出（2 个新 path，含 ExperienceFeedbackCreate / ExperienceHintItem / ExperienceHintsResponse 三个新 schema）→ `npm run gen:api` 再生 types/api.ts → `npm run build` 通过。**后端基线**：**192 passed, 13 skipped**（批 3 不改后端）；**前端构建**：vue-tsc + vite 通过，ResultView 包大小 37.18 kB / 11.91 kB gzip。**D17 闭环端到端可用**：admin / process_engineer 在 ResultView 点"👍 老师傅反馈" → Dialog 选"采纳"+ 写原因 → 提交 → 角标即时刷新（重拉 hints）；下次同指纹 STP 分析，`PartingCandidateGenerator` 候选方向加成 + `PartingSchemeScorer` total_score 加成 + method 标签升级 `human_experience_primary`。**下一步**：批 4（衰减机制完善 + DFM 规则库独立模块化 + 经验冲突仲裁 UI）按需排期。）
+
+> 2026-09-23（**D17 Human-in-Loop 老师傅经验反馈批 2 上线（算法接缝 + OCC payload 通道）——闭环通**：① 算法层 4 个核心文件加 `hints` 形参透传链：[parting_candidate_generator.py:13-66](src/moldinsight/core/parting_candidate_generator.py#L13-L66) `_build_axis_metrics` 末尾按 hints 加成（`weight × 20` 上限，`sample_count ≥ 2 + weight ≥ 0.5` → method 标签升级 `human_experience_primary`）；[parting_scheme_scorer.py:8-46](src/moldinsight/core/parting_scheme_scorer.py#L8-L46) `_score_scheme` 新增 `human_hint_bonus` 字段（weight × 12 上限，sample_count < 2 时 ×0.5 折半），纳入 total_score；[multi_scheme_planner.py:26-86](src/moldinsight/core/multi_scheme_planner.py#L26-L86) `generate_plan` 透传 hints 到下两层，`global_summary.applied_hints` 注入返回；② [processing_service.py:531-595](src/moldinsight/services/processing_service.py#L531-L595) `_step_generate_cavity` 调 `experience_feedback_service.resolve_for_process_params` 拿同指纹 hints，装进 run_occ payload 顶层 `experience_hints` 字段（普通 dict 透传，pickle 安全，满足 [occ_worker.py:7-8](src/moldinsight/core/occ_worker.py#L7-L8) 硬规则）；③ [occ_worker.py:117-140](src/moldinsight/core/occ_worker.py#L117-L140) `_op_generate_cavity` 读 `payload.get("experience_hints") or {}` 透传给 `planner.generate_plan(..., hints=...)`；④ D17 闭环验证：老师傅写一条同指纹 `adopted` → 同 X 通道下次分析 `priority_score` +18，`score_breakdown.human_hint_bonus` +12（sample_count=3），method 标签升级 `human_experience_primary`。**接口面零变化**（路径 / schema 不动；仅 OCC 子进程内部响应含 `global_summary.applied_hints`，由前端 ResultView 渲染角标——批 3 实现）。**测试基线**：**192 passed, 13 skipped**（批 2 净增 7 通过 + 4 OCC-gated skip：candidate_generator 3 例 / scheme_scorer 4 例在无 OCC 环境跑通，multi_scheme_planner + processing_service 4 例 OCC-gated 待 conda `gemold` 镜像验证）。**接口变更三件套执行节点**：openapi.json 重导出与前端 `gen:api` 待批 3 完成后一并执行（前端调用两 path + ResultView 渲染一并改）。**下一步**：批 3 前端（ResultView 按钮组 + `HumanFeedbackDialog.vue` + `moldinsightApi` 两个方法 + 经验角标）。）
+
+> 2026-09-23（**D17 Human-in-Loop 老师傅经验反馈批 1 上线（数据 + 权限 + 写入 API）**：① 新增 `experience_feedback` 表（32 表迁移，alembic head `b7d1f4a92c3e`）——老师傅对系统推荐方案给出"采纳 / 调整 / 拒绝"反馈，按"产品指纹 + 工艺参数"为键跨任务匹配，下次同指纹产品分析自动消费；② 新增 3 个权限码（`view_experience_feedback` / `feedback_experience_hint` / `manage_experience_feedback`）+ 新角色 `process_engineer`（含 view + feedback 权限，admin 角色 permissions 同步补齐）；③ 新增 2 个端点（`POST /api/tasks/{task_id}/experience-feedback` 提交反馈 + `GET /api/tasks/{task_id}/experience-hints` 拉取同指纹历史 hints 摘要）；④ `init_db.py` 幂等 bug 修复——既有 DB 启动期不再跳过新增权限 / 角色补登（`init_permissions` / `init_roles` 改为按 code 比对，新增保留已有 id）；⑤ ORM / 迁移 / service / router / api 注册均落位：D9 边界（service.flush + 路由 commit）；D17 衰减（写新反馈时同 `stp_file_id` 整体续期 90 天 TTL）；`User.has_permission` 全仓首次调用点（[src/shared/models/identity.py:38](src/shared/models/identity.py#L38) 此前仅定义零调用）。**接口面新增 2 path**（openapi.json 重导出随批 3 一并执行——批 2 OCC payload 接缝改了 `/api/status/{task_id}` 实际响应结构需等到 OCC 集成落地再重导出）。**测试基线**：**185 passed, 9 skipped**（批 1 净增 59 测试，含 `compute_fingerprint` 分桶参数化覆盖 bbox / volume / face / undercut / material / is_foam 各边界值 + API 契约 401/403/422/200 路径 + 衰减续期 + 任务归属校验 + ORM 注册收口）。**下一步**：批 2 算法接缝（PartingCandidateGenerator / PartingSchemeScorer / MultiSchemeMoldPlanner 透传 hints + OCC worker payload `experience_hints` 通道）+ 批 3 前端按钮 + 反馈 Dialog + 经验角标渲染。）

 > 2026-09-22（**Pydantic v2 schema 配置升级 + `datetime.utcnow()` 弃用清零**：① 全仓 14 处 `class Config`（[src/inventory/schemas](../src/inventory/schemas/)）+ [src/shared/services/auth_routes.py](../src/shared/services/auth_routes.py) 三处全部迁移到 `model_config = ConfigDict(from_attributes=True)`；② [src/shared/services/auth_service.py](../src/shared/services/auth_service.py) 中 `datetime.utcnow()` 改用 `datetime.now(timezone.utc)`，消除遗留 `DeprecationWarning`；③ 一次跑通 `pytest tests/ -q` 全量无 deprecation 警告，全仓 `from_attributes=True` 语义保持不变，未触发 OpenAPI 漂移。**测试基线**：**126 passed, 4 skipped**（与上一批次一致，无回归）。）
 >
+> 2026-09-22（**D13 锁文件流程固化：镜像引入已清偿 + 落锁流程就绪**：① 新增 [deploy/generate_lockfiles.sh](../deploy/generate_lockfiles.sh) / [.bat](../deploy/generate_lockfiles.bat)：在 moldinsight conda 环境（仅项目依赖，**不能**在混装开发栈跑）执行 `pip freeze --exclude pythonocc-core`，产出 `deploy/requirements-{base,moldinsight}.lock.txt`；② [Dockerfile.moldinsight](../deploy/Dockerfile.moldinsight) 注释改为指向生成脚本；③ [docs/OPERATIONS.md](../docs/OPERATIONS.md) §2.1 增加完整流程说明（生成时机 / 命令 / 产物 / 消费方 / 提交策略）；④ [tests/test_lockfile_generation.py](../tests/test_lockfile_generation.py) 加锁文件存在性 + 体积契约，默认 skip（仓库单测不阻塞），CI 镜像构建 job 显式 `pytest --run-lockfile-check` 启用 fail-fast。**遗留**：锁文件本身尚未落盘——本机 Miniforge 装的是跨项目开发栈混装环境，污染严重不能直接用 `pip freeze`；须等 CI / 生产机器首次构建 moldinsight 镜像后按流程落锁。**测试基线**：**126 passed, 9 skipped**（默认 4 个原有 skip + D13 新增 5 个 skip；启用 `--run-lockfile-check` 时严格断言 2 项锁文件契约）。）
+>
+> 2026-09-02 起（含 09-17 之前基线条目）的完整内容见 [archive/2026-09_status_history.md](archive/2026-09_status_history.md)。
+>
 > 2026-09-21（**inventory 仪表盘聚合服务下沉完成：dashboard 薄路由化**：① 新增 [dashboard_service.py](../src/inventory/services/dashboard_service.py)，将仪表盘首页所需的基础主数据统计、物料库存总量/总值、待处理采购/销售单数、低库存预警列表等聚合查询从路由层下沉到 service；② [dashboard_routes.py](../src/inventory/api/dashboard_routes.py) 改为单行委托薄路由，inventory 主要业务域路由已基本完成 service orchestration 收口；③ 新增 [test_api_dashboard_service.py](../tests/test_api_dashboard_service.py)，覆盖 seeded summary 与低库存预警两条 API 回归。**接口面零变化**（无 openapi 漂移）。**测试基线**：**126 passed, 4 skipped**；新增 dashboard 回归 **2 passed**。）
 >
 > 2026-09-21（**inventory 产品域跨模块桥接收口完成：`/api/products/from-task/{task_id}` 下沉至 `product_service`**：① [product_service.py](../src/inventory/services/product_service.py) 新增 `create_product_from_task`，将 ProcessingTask / STPFile 查询、已绑定成品幂等返回、`MI{stp_file_id}` SKU 冲突递增、分析结果摘要拼装、成品创建与 `stp_files.product_id` 回写从路由层下沉到 service；② [product_routes.py](../src/inventory/api/product_routes.py) 现已全量薄路由化，产品域 CRUD / BOM / from-task 三类接口统一改为 service orchestration；③ 扩展 [test_api_product_service.py](../tests/test_api_product_service.py) 与 [tests/conftest.py](../tests/conftest.py)，补 `STPFile` / `ProcessingTask` 种子及 from-task 创建、重复调用幂等、任务不存在 404 回归。**接口面零变化**（无 openapi 漂移）。**测试基线**：**124 passed, 4 skipped**；product 域回归现为 **14 passed**。）
@@ -18,59 +18,33 @@

 ---

-## 2. 已完成的重要治理（摘要）
+## 2. 已完成的重要治理（主题摘要）

-以下高价值治理已完成：
+按主题归类的高价值治理已完成项。每项的具体修复清单 / 迁移号 / 回归测试 / 测试基线见归档：
+
+- [archive/2026-09_governance_batches.md](archive/2026-09_governance_batches.md)：批次 0–4 + 后续专项 + 2026-09-21 inventory 服务下沉 + 2026-09-22 schema/datetime 弃用清零 的完整流水账
+- [archive/MOLDINSIGHT_TECH_DEBT_PLAN.md](archive/MOLDINSIGHT_TECH_DEBT_PLAN.md)：更早的设计审查原始计划

 ### 2.1 安全与权限
- debug/history 路由补鉴权
- 任务访问控制收紧
- 无主数据不再默认放行
- `/api/status/{task_id}` 补 JWT 鉴权与归属校验（原 D5，2026-09-16 清偿，见 D5 条目）
- bcrypt 创建口令超 72 字节显式拒绝、验证侧截断比较；`SECRET_KEY` / `RUSTFS_*` 缺失时明确报错，代码侧弱默认移除（D14 部分，2026-09-16）
+- debug / history 路由补鉴权；任务访问控制收紧；无主数据不再默认放行
+- `/api/status/{task_id}` 补 JWT 鉴权与归属校验（原 D5 → §3 D5）
+- bcrypt 超 72 字节显式拒绝 + 截断比较；`SECRET_KEY` / `RUSTFS_*` 缺失明确报错

 ### 2.2 静默失败与可用性
 - `detect-undercuts` 改为基于真实 shape 分析
- OCC 超时后重建 executor，避免全队列永久堵死
+- OCC 超时后重建 executor（短期）→ D10 方案 B 进程化彻底替换
 - 后台任务统一分派，补强引用与并发控制

 ### 2.3 状态存储与缓存
 - Redis 任务状态改为 Hash 字段级更新，兼容旧格式
- 完成态任务视图增加缓存
- 导出缓存与持久化链路收口，支持重启后再导出
+- 内存回退彻底删除，PG 为任务状态单一事实源（原 D7）
+- 完成态任务视图缓存；导出缓存与持久化链路收口

 ### 2.4 架构与代码清理
- 删除旧单体入口与死代码
- 设置惰性配置校验，提升可测试性
- Generator 公共接口提取完成，补充契约测试
-
-### 2.5 部署正确性（2026-09-16，批次 0/1）
- `/api/status/{task_id}` 补鉴权与归属校验（原 D5）
- 主处理链路改走 RustFS：分派入参 `stp_file_id` 化，源文件按 object_key 下载；compose 共享卷过渡兜底（原 D6）
- `AUTO_MIGRATE` 开关 + 迁移脚本随镜像分发 + `alembic/`→`migrations/` 改名修复包遮蔽（原 D12）
- OCC 镜像改 conda 运行时原生执行、基础镜像 tag 锁定（D13 主体）；compose 关键项去弱默认（D14 部分）
-
-### 2.6 任务一致性模型（2026-09-16，批次 2）
- Redis 内存回退彻底删除，PG 为任务状态单一事实源（原 D7）；批量元数据入库（`processing_tasks.batch_id`，迁移 `a3f8c2d91e47`）
- 型腔生成失败任务标 failed，不再静默 completed（原 D8）
- 持久化事务边界收口：数据本体分阶段原子提交、失败先回滚再置 failed（原 D9）
- D11（HTML 双写双读）本批未动：正确性已由共享卷兜底，RustFS 单一来源留待后续批次
-
-### 2.7 API 与代码结构（2026-09-17，批次 3）
- `advanced_router` 按职责拆为 design / cost / machining / export 四个子路由，端点路径不变，请求体全量 Pydantic 化（原 D1）
- 路由装载失败显式化：`ROUTE_MODULES` 清单 + route_registry，失败经 `/api/health` 呈现 degraded（含真实 pythonocc 探测），DEBUG 下 fail fast
- 纯 Python 重计算端点（设计/加工/CAM 打包）统一 `asyncio.to_thread` 投放线程池，不再阻塞事件循环；OCC 操作仍走单线程 executor（D10 不变，批次 4）
- `StorageIntegrationService`（867 行）按职责拆为 TaskStorage / AnalysisStorage / FileHistory 三服务；无调用方的 `log_user_activity` 死代码删除
- 配置治理收尾：`MAX_FILE_SIZE` 接线生效、celery_app 复用 `Settings.redis_url`（原 D14）
- 连带修复：管理员重置密码改 JSON body（原裸 str 参数被解析为 query param，前端发 body 必 422，功能端到端断裂）；Dockerfile.celery 的 FROM tag 与 compose/build.sh 实际构建的 `gemold-backend:latest` 对齐（此前干净环境 celery 镜像必构建失败）
- 接口变更三件套随批完成：openapi.json 重导出（76 paths）+ 前端 `gen:api`
-
-### 2.8 架构演进（2026-09-17，批次 4）
- 共享 ORM 按模块拆分（原 D3 主体）：891 行 `shared/models/database.py`（31 模型类三类同居）拆为 `shared/models/base.py`（唯一 Base + 归属约定）/ `shared/models/identity.py`（7 表）/ `moldinsight/models/`（9 表）/ `inventory/models/`（catalog/warehouse/trading/finance 15 表）；**三条跨模块 ORM relationship（`User.stp_files`、`STPFile.user`、`STPFile.product`）经全仓核实均无使用方，直接删除**——跨模块桥接收敛为裸 FK 硬规则（ARCHITECTURE §5.1），单模块部署不再依赖另一侧模型注册；约 45 处 import 全量改写，无兼容 facade；全量注册点收敛为 migrations/env.py 与 tests/conftest.py；零调用方的死方法 `db_manager.create_tables` 一并删除（拆分后会静默建残缺 schema）
- OCC 泄漏治理 + 吞吐方案设计先行（原 D10）：`_reset_occ_executor` 补 `cancel_futures=True`——不止卫生问题：旧实现下"慢恢复"的旧线程会继续消化旧队列，与新 executor **并发操作非线程安全的 OCC**（数据竞争）；吞吐路线定稿于 [topics/performance/OCC_THROUGHPUT.md](topics/performance/OCC_THROUGHPUT.md)（短期 A：celery prefork 伸缩 + max-tasks-per-child 兜底；中期 B：run_occ 接口进程化 + kill-on-timeout 根治）
- 归属边界回归测试：[tests/test_model_ownership.py](../tests/test_model_ownership.py)（31 表全量注册、单模块独立 mapper 配置、旧模块无 facade）
-
-详细历史过程保留在原始技术债文档中，后续将转入归档。
+- 删除旧单体入口与死代码（`db_manager.create_tables` / `log_user_activity` / `CADExporter.export_mold_results` / `getAluminumPrice` 等）
+- 惰性配置校验，提升可测试性
+- Generator 公共接口提取 + 契约测试
+- 共享 ORM 按模块拆分，跨模块桥接收敛为裸 FK 硬规则（ARCHITECTURE §5.1）

 ---

@@ -86,24 +60,19 @@

 ~~原现状 / 影响~~：导出/估算/设计接口混在单文件，边界不清晰、OpenAPI 可读性差、参数校验不统一。

-### D2. 铝价模拟数据未显式标注来源
+### D2. 铝价模拟数据未显式标注来源 —— 已清偿（2026-09-18，批次 4 后续专项）

-现状：
- 铝价服务返回的是模拟/参考数据，但接口层未明确表达
+修复内容（保留编号以维持引用稳定）：
+- [src/moldinsight/services/aluminum_price_service.py](../src/moldinsight/services/aluminum_price_service.py)：`get_aluminum_current_price` 响应补 `source: "simulated"`，`get_aluminum_price_history` 逐项补同字段
+- [frontend/src/modules/home/HomeView.vue](../frontend/src/modules/home/HomeView.vue)：按 `source` 字段渲染"模拟数据 · 参考走势，非实时行情"标注（不再硬编码"上海期货交易所"等虚假来源）
+- 死代码 `getAluminumPrice` 删除（前端此前保留了一份本地硬编码函数，已无调用方）

-影响：
- 容易误导前端与业务使用者，把模拟数据理解为实时行情
-
-建议：
- 响应增加 `source: "simulated"`
- 前端界面同步标注“模拟/参考数据”
-
-优先级：**P2**
+~~原现状 / 影响~~：铝价接口返回走势数据但无来源声明，前端原硬编码"上海期货交易所"字样，与实际模拟数据不一致，属虚假来源声明。

 ### D3. shared/platform 边界仍需继续收敛 —— 主体已清偿（2026-09-17 批次 4 + 2026-09-18 后续）

-已完成部分：
- 共享 ORM（原最强耦合点）按模块拆分：base / identity（shared）+ moldinsight/models + inventory/models；跨模块只允许裸 FK，单模块部署 mapper 可独立配置（详见 §2.8 与 [ARCHITECTURE.md](ARCHITECTURE.md) §6.1）
+已完成部分（修复文件清单见 [archive/2026-09_governance_batches.md](archive/2026-09_governance_batches.md) 批次 4 / 后续专项）：
+- 共享 ORM（原最强耦合点）按模块拆分：base / identity（shared）+ moldinsight/models + inventory/models；跨模块只允许裸 FK，单模块部署 mapper 可独立配置（详见 [ARCHITECTURE.md](ARCHITECTURE.md) §6.1）
 - 旧 `shared/models/database.py` 物理删除，无兼容 facade；归属边界由 [tests/test_model_ownership.py](../tests/test_model_ownership.py) 锁定
 - **app_factory 组合职责收敛**（2026-09-18）：平台工厂只做纯平台引导，`connect_rustfs` 参数移除；moldinsight 专属接线（RustFS 启动钩子 [init_storage.py](../src/moldinsight/storage/init_storage.py) `rustfs_startup_hook`、路由单点聚合 [moldinsight/api/__init__.py](../src/moldinsight/api/__init__.py) `register_moldinsight_routers`）收敛回模块层，入口退化为纯组装（ARCHITECTURE §6.2）

@@ -112,21 +81,14 @@

 优先级：**P3**（仅剩 identity/platform 语义注释口径）

-### D4. 文档现状 / 规划 / 历史混放
+### D4. 文档现状 / 规划 / 历史混放 —— 已清偿（2026-09-22）

-现状：
- 文档存在部署说明重叠、计划/总结/权威文档混放
- README 承担过多职责
+修复内容（保留编号以维持引用稳定）：
+- 已建立 `STATUS / ARCHITECTURE / ROADMAP / TECH_DEBT / DEPLOYMENT` 主骨架，每类信息单一归属；历史材料归档至 `docs/archive/`
+- 本文档 §2 由"按批次回顾"精简为"按主题摘要"，修复文件清单 / 迁移号 / 回归测试 / 测试基线等详细流水账整体迁入 [archive/2026-09_governance_batches.md](archive/2026-09_governance_batches.md)（避免与 §3 重复膨胀）
+- §3 中对历史批次的引用（如 D3 → §2.8）改为 archive 指针；D2 等已清偿项补齐时间戳

-影响：
- 新成员难以判断“哪篇才是当前有效说法”
- 状态、部署、规划容易发生漂移
-
-建议：
- 建立 `STATUS / ARCHITECTURE / ROADMAP / DEPLOYMENT` 主骨架
- 历史材料迁入 `docs/archive/`
-
-优先级：**P1**
+~~原现状 / 影响~~：TECH_DEBT §2 与 §3 内容重复膨胀，文档目录结构清晰度受新成员评估影响。

 ### D5. `/api/status/{task_id}` 未鉴权（安全缺口）—— 已清偿（2026-09-16，批次 0）

@@ -222,13 +184,18 @@
 - 语义保持：仅切换 Pydantic v2 配置语法 + UTC 时区语义，字段 / OpenAPI / JWT 行为零变化
 - 验证：`pytest tests/ -q` **126 passed, 4 skipped**，deprecation warning 全部清零

-### D13. PythonOCC 镜像引入方式脆弱 + 依赖无版本锁（主体已清偿，锁文件遗留）
+### D13. PythonOCC 镜像引入方式脆弱 + 依赖无版本锁（镜像引入已清偿；锁文件流程已固化，待首次构建落盘）

 现状：
 - ~~从 conda env 拷贝 site-packages 进 python:3.12-slim~~（2026-09-16 已修正：[Dockerfile.moldinsight](../deploy/Dockerfile.moldinsight) 改为 conda 运行时原生执行，不再跨镜像拷贝；基础镜像 tag 锁定 `continuumio/miniconda3:24.7.1-0`、`python:3.12-slim-bookworm`；tag 可用性随下次镜像构建验证）
- [requirements.txt](../requirements.txt) 全部为 `>=` 下限，无锁文件（**遗留**：首次镜像构建成功后 `pip freeze` 生成锁文件，命令已注释在 Dockerfile 内）
+- 锁文件流程已固化（2026-09-22）：
+  - 新增 [deploy/generate_lockfiles.sh](../deploy/generate_lockfiles.sh) / [generate_lockfiles.bat](../deploy/generate_lockfiles.bat)：在 moldinsight conda 环境（仅项目依赖，**不能**在混装开发栈跑）执行 `pip freeze --exclude pythonocc-core`，产出 `deploy/requirements-{base,moldinsight}.lock.txt`
+  - [Dockerfile.moldinsight](../deploy/Dockerfile.moldinsight) 注释改为指向生成脚本
+  - [docs/OPERATIONS.md](../docs/OPERATIONS.md) §2.1 增加完整流程说明（生成时机 / 命令 / 产物 / 消费方 / 提交策略）
+  - [tests/test_lockfile_generation.py](../tests/test_lockfile_generation.py) 加锁文件存在性 + 体积契约；默认 skip（仓库单测不阻塞），CI 镜像构建 job 显式 `pytest --run-lockfile-check` 启用
+- **遗留**：锁文件本身尚未落盘——本机 Miniforge 装的是跨项目开发栈混装环境，污染严重不能直接用 `pip freeze`；须等 CI / 生产机器首次构建 moldinsight 镜像后，按流程跑 `bash deploy/generate_lockfiles.sh` 落锁并提交。已存在护栏：CI 镜像构建 job 跑 `--run-lockfile-check` 后若未落盘会 fail-fast，强制流程走通

-优先级：**P2**（剩余锁文件部分）
+优先级：**P2**（流程已固化，剩"首次构建后落盘"一次性产物）

 ### D14. 配置漂移：弱默认 / 死配置 / 重复解析 —— 已清偿（2026-09-16 ~ 09-17，批次 1 / 3）

@@ -246,6 +213,40 @@

 ~~原现状 / 影响~~：`vue-tsc -b`（`npm run build` 的类型检查步）因既有 TS6133 失败，前端无法出生产包（与批次 3 改动无关的既有问题）。

+### D17. 算法成熟度距"老师傅经验"差距 + Human-in-Loop 闭环 —— 批 1 已清偿（2026-09-23）
+
+**背景**：现有算法（分模 / 倒扣 / 评分 / DFM 校验）是 OCC BREP 上的工程启发式，距模具师傅"看完就知道该咋改"的实战经验仍有结构性差距——倒扣邻接聚类缺失、滑块 / 斜顶设计是纯几何启发、DFM 规则库仅 4 条、评分权重拍脑袋（详见 2026-09-22 用户对话评估）。
+
+**方案**：引入 Human-in-Loop 闭环——老师傅对系统推荐方案给出"采纳 / 调整 / 拒绝"反馈，以"产品指纹 + 工艺参数"为索引跨任务匹配，**下次同指纹产品分析自动消费这些经验**（OCC worker payload 透传 → MultiSchemeMoldPlanner → PartingSchemeScorer 加成）。老师傅的经验以结构化数据沉淀，避免成为"知识库坟墓"。
+
+**批 1 已完成（数据 + 权限 + 写入 API）**：
+- 新增 `experience_feedback` 表（alembic head `b7d1f4a92c3e`，32 表迁移），含 fingerprint JSON 列（PG 下 GIN 索引支持 jsonb_path_query）
+- 3 个权限码（`view_experience_feedback` / `feedback_experience_hint` / `manage_experience_feedback`）+ 新角色 `process_engineer`；admin 角色 permissions 同步补齐
+- `init_db.py` 幂等 bug 修复——既有 DB 启动期不再跳过新增权限 / 角色补登（`init_permissions` / `init_roles` 改为按 code 比对，新增保留已有 id，避免 FK 引用失效）
+- 新增端点 `POST /api/tasks/{task_id}/experience-feedback`（提交方案级反馈；`TaskQueryService.ensure_task_access` 归属校验 + `User.has_permission` 全仓首次调用）+ `GET /api/tasks/{task_id}/experience-hints`（按 material_family + is_foam 锚定的历史聚合）
+- D9 边界遵守：service.flush + 路由 commit；D17 衰减机制：写新反馈时同 `stp_file_id` 整体续期 90 天 TTL（无 celery beat 依赖）
+- 测试基线：185 passed, 9 skipped（批 1 净增 59 测试）
+
+**批 2 已完成（算法接缝 + OCC payload 通道）—— 闭环通**：
+- [parting_candidate_generator.py](src/moldinsight/core/parting_candidate_generator.py) `generate_candidates(..., hints=None)`：`priority_score += weight × 20`，`sample_count ≥ 2 + weight ≥ 0.5` 时 method 标签升级 `human_experience_primary`
+- [parting_scheme_scorer.py](src/moldinsight/core/parting_scheme_scorer.py) `score_schemes(..., *, hints=None)`：新增 `score_breakdown["human_hint_bonus"]`（`weight × 12`，`sample_count < 2` 时 ×0.5 折半），纳入 total_score；keyword-only 防与位置参数混淆
+- [multi_scheme_planner.py](src/moldinsight/core/multi_scheme_planner.py) `generate_plan(..., hints=None)`：透传 hints 到下两层，`global_summary.applied_hints` 注入返回供前端展示
+- [processing_service.py](src/moldinsight/services/processing_service.py) `_step_generate_cavity`：调 `experience_feedback_service.resolve_for_process_params` 拿同指纹 hints，装进 run_occ payload 顶层 `experience_hints`；解析失败回退空 list 不阻塞主流程
+- [occ_worker.py](src/moldinsight/core/occ_worker.py) `_op_generate_cavity`：`payload.get("experience_hints") or {}` 透传给 `planner.generate_plan`，普通 dict 跨进程 pickle 安全
+- 测试基线：192 passed, 13 skipped（批 2 净增 7 通过 + 4 OCC-gated skip）
+
+**批 3 已完成（前端按钮 + Dialog + 经验角标）—— 闭环可视**：
+- [ResultView.vue:35-47](frontend/src/modules/moldinsight/ResultView.vue#L35-L47) 方案卡片 summary-header 加 `t-tag` 经验角标（`currentAxisHint` computed 按 scheme_axis 索引 hintsByAxis，无 hints 不渲染）
+- [ResultView.vue:131-138](frontend/src/modules/moldinsight/ResultView.vue#L131-L138) `export-buttons-bar` 加 `👍 老师傅反馈` 按钮（`v-if="canGiveFeedback"` 角色门控：admin 或 process_engineer）
+- [HumanFeedbackDialog.vue](frontend/src/modules/moldinsight/components/HumanFeedbackDialog.vue) 新组件：t-dialog + t-form + t-radio-group 三选一 + t-textarea；走 `moldinsightApi.submitExperienceFeedback`，成功后 emit `submitted` 让父组件重拉 hints
+- [shared/api-client.ts:407-444](frontend/src/shared/api-client.ts#L407-L444) `moldinsightApi` 新增 `getExperienceHints` / `submitExperienceFeedback`
+- 接口变更三件套随批完成：openapi.json 重导出（2 新 path）→ `npm run gen:api` → `npm run build` 通过
+
+**剩余工作（按需排期）**：
+- 批 4：衰减机制完善（与 DB 一致性定期核查）+ DFM 规则库独立模块化 + 经验冲突仲裁 UI
+
+~~原现状 / 影响~~：算法生成的方案与真实工程决策有差距，老师傅每次都要推翻系统建议重来，沉淀经验无结构化路径。
+
 ---

 ## 4. 当前推荐治理顺序
@@ -0,0 +1,100 @@
+# 2026-09 后端设计治理批次实施流水账（归档）
+
+> 文档定位：**2026-09 设计审查产出的批次 0–4 与后续专项的完整实施流水账**。
+> 主骨架权威文档见：
+> - [../STATUS.md](../STATUS.md)（每批次完成的时间点与产物）
+> - [../TECH_DEBT.md](../TECH_DEBT.md)（活跃债务 / 已清偿项的当前位置）
+> - [../ROADMAP.md](../ROADMAP.md)（批次计划与执行顺序）
+> - [../ARCHITECTURE.md](../ARCHITECTURE.md)（平台 / 模块边界当前定稿）
+
+## 批次 0（2026-09-16，安全与诚实）
+
+- `/api/status/{task_id}` 补 JWT 鉴权 + 任务归属校验（无 token 401 / 他人或无主任务 403 / 不存在 404）
+- 归属校验收敛为 `TaskQueryService.ensure_task_access` 供 task_router 与 advanced_router 共用（原 D5）
+- 上传预检 `pythonocc_available` 从硬编码 true 改为惰性真实探测
+- bcrypt 口令治理：创建侧超 72 字节显式拒绝、验证侧截断比较
+- `SECRET_KEY` 未配置 / `RUSTFS_*` 缺失时惰性校验抛明确错误
+- 完成态任务未持久化 `analysis_metrics` 时 `/api/status` 组装视图 500 修复
+- 测试基线：96 passed
+- 回归测试：`tests/test_status_endpoint_auth.py` 8 项
+- 接口行为变化已同步 [../API_CONTRACT.md](../API_CONTRACT.md) §3.2
+
+## 批次 1（2026-09-16，部署正确性）
+
+- 主处理链路改走 RustFS：分派入参 `file_path` → `stp_file_id`（原 D6）
+- 处理方按 PG 元数据从 RustFS 下载源文件到任务专属临时目录（保留原始文件名，下游产物命名不变），任务结束即清理
+- RustFS 不可用时回退 `STPFile.file_path` 节点本地路径；compose 为 backend / celery 增加共享卷 `uploads_data` / `html_data` 作过渡兜底
+- `AUTO_MIGRATE` 开关（settings / .env.example / compose 透传），默认 `true` 保持单机开发行为（原 D12）
+- 迁移目录 `alembic/` → `migrations/`（修复 `import alembic` 命中本地目录遮蔽真实包的命名冲突）+ Docker 镜像补 `COPY migrations/` + `COPY alembic.ini`
+- Dockerfile.moldinsight 改为 conda 运行时原生执行，基础镜像 tag 锁定（原 D13 主体）
+- compose 关键项去弱默认：`SECRET_KEY` / `ADMIN_PASSWORD` 改 `${VAR:?}` 强制显式配置；`create_admin_user` 对空口令显式报错
+- 测试基线：98 passed, 1 skipped
+- 回归测试：`tests/test_deployment_config.py`
+
+## 批次 2（2026-09-16，任务一致性模型）
+
+- Redis 进程内存回退彻底删除（写 no-op / 读 None，Redis 仅热缓存），PG 为任务状态单一事实源（原 D7）
+- 批量元数据入库：`processing_tasks` 新增 `batch_id` 列（迁移 `a3f8c2d91e47`），`GET /api/batch/{batch_id}` 改为 PG 聚合查询 + `STPFile.user_id` 归属校验
+- 删除 Redis batch key 与进程内 dict 双通道
+- `TaskQueryService` PG 视图与 batch 聚合响应补 `progress` / `current_step`
+- 型腔分模失败不再吞异常 → 任务 failed（原 D8）
+- 持久化事务边界收口：数据本体写方法只 flush，编排层分阶段原子收口（阶段 A 几何+网格、阶段 B 型腔+HTML+特征+指标+验证），失败先 rollback 再置 failed（原 D9）
+- 进度/状态更新保留即时 commit（长任务进度可见性）
+- 测试基线：105 passed, 1 skipped
+- 回归测试：`tests/test_batch_status_pg.py` 4 项 + `tests/test_redis_no_fallback.py` 3 项
+
+## 批次 3（2026-09-17，API 与代码结构）
+
+- `advanced_router` 按职责拆为 design / cost / machining / export 四个子路由，端点路径不变（原 D1）
+- 全部请求体改 Pydantic 模型（`request.json()` 手动解析退役），校验失败统一 422
+- `_get_cached_import` 上提为 `core_modules.py` 共用
+- 路由装载失败显式化：`ROUTE_MODULES` 清单 + `route_registry`，失败经 `/api/health` 呈现 degraded（`pythonocc` 真实探测），DEBUG 下 fail fast
+- 纯 Python 重计算端点统一 `asyncio.to_thread` 投放线程池，不再阻塞事件循环
+- `StorageIntegrationService`（867 行）按职责拆为 TaskStorage / AnalysisStorage / FileHistory 三服务（原 D14 部分）
+- `MAX_FILE_SIZE` 接线生效、celery_app 复用 `Settings.redis_url`（原 D14 收尾）
+- 连带修复：管理员重置密码改 JSON body（原裸 str 参数被解析为 query param，前端发 body 必 422）；Dockerfile.celery 的 FROM tag 与实际构建 tag 对齐
+- 接口变更三件套随批完成：openapi.json 重导出（76 paths）+ 前端 `gen:api`
+- 测试基线：122 passed, 2 skipped
+- 回归测试：4 个测试文件共 17 项（`test_advanced_split_contract` / `test_route_load_status` / `test_config_governance` / `test_auth_password_reset`）
+
+## 批次 4（2026-09-17，架构演进）
+
+- 共享 ORM 按模块拆分（原 D3 主体）：891 行 `shared/models/database.py`（31 模型类三类同居）拆为 `shared/models/base.py`（唯一 Base + 归属约定）/ `shared/models/identity.py`（7 表）/ `moldinsight/models/`（9 表）/ `inventory/models/`（catalog/warehouse/trading/finance 15 表）
+- 三条跨模块 ORM relationship（`User.stp_files` / `STPFile.user` / `STPFile.product`）经全仓核实均无使用方，直接删除；跨模块桥接收敛为裸 FK 硬规则（[../ARCHITECTURE.md](../ARCHITECTURE.md) §5.1）
+- 约 45 处 import 全量改写，无兼容 facade
+- 全量注册点收敛为 migrations/env.py 与 tests/conftest.py
+- 零调用方的死方法 `db_manager.create_tables` 一并删除
+- `_reset_occ_executor` 补 `cancel_futures=True`（旧实现下"慢恢复"的旧线程会继续消化旧队列，与新 executor **并发操作非线程安全的 OCC**，属数据竞争而非单纯泄漏，原 D10 短期治理）
+- 吞吐路线定稿于 `topics/performance/OCC_THROUGHPUT.md`（短期 A：celery prefork 伸缩 + max-tasks-per-child 兜底；中期 B：run_occ 接口进程化 + kill-on-timeout 根治）
+- 顺手清偿 D15：`vite.config.ts` 删除未用的 `mode` 参数，`vue-tsc -b` 恢复通过
+- 回归测试：`tests/test_model_ownership.py`（31 表全量注册 / 单模块独立 mapper 配置 / 旧模块无 facade）
+- 测试基线：125 passed, 2 skipped
+- 接口面零变化（无 openapi 重导出）
+
+## 批次 4 后续专项（2026-09-18）
+
+- D11 清偿：可视化报告 RustFS 单源化
+  - 写侧 HTMLGenerator 每任务写临时目录，`.html`/`_summary.json`/`_data.json` 三件统一裸传 RustFS 报告键 `html/reports/{filename}`
+  - 读侧 `/html` StaticFiles 本地挂载删除，新增代理路由 `html_report_router.py`（报告键直取 → 遗留 `html/{hash}.json` JSON 包装解析 → 本地卷存量兜底 → 404）
+  - 防路径穿越（单段文件名校验），URL 形状 `/html/{filename}` 不变
+  - 部署：celery 服务摘除 `html_data` 卷；Dockerfile.moldinsight 删除 `COPY html_output/`
+  - 已知约束：报告路由不做认证（iframe 无法携带 Authorization 头）
+  - 删除 `get_stp_file_with_data` 的死数据块
+- OCC 方案 A 部署参数落地：`CELERY_CONCURRENCY` / `CELERY_MAX_TASKS_PER_CHILD` 进 Dockerfile.celery + compose + .env.example
+- D2 清偿：铝价响应带 `source: "simulated"`；前端按来源渲染"模拟数据 · 参考走势"标注；死代码 `getAluminumPrice` 删除
+- D10 方案 B 实施：`run_occ(fn, *args)` → `run_occ(op_name, payload)`；常驻 OCC 进程池 + kill-on-timeout 根治残留线程泄漏
+- CI 门禁：`.gitea/workflows/ci.yml` 三 job（pytest / 前端构建 / openapi 漂移检测）
+- 接口变更三件套随批完成：openapi.json 重导出（76→77 paths，新增 `/html/{filename}`）+ 前端 `gen:api` 再生
+- 测试基线：143 passed, 0 skipped
+
+## 后续小步治理（2026-09-21 ~ 2026-09-22）
+
+- 2026-09-21 inventory 业务层继续沉淀批次（4 批）：
+  - `customer / supplier / warehouse` → `master_data_service`
+  - `material_routes`（价格历史 / 趋势 / 供应商关联）→ `material_service`
+  - `product_routes`（CRUD / BOM / from-task 跨模块桥接）→ `product_service`
+  - `dashboard_routes`（首页统计 / 低库存预警）→ `dashboard_service`
+- 2026-09-22 schema / datetime 现代化弃用清零（D12）：
+  - 全仓 14 处 `class Config:` + auth_routes 三处全部迁移到 `model_config = ConfigDict(from_attributes=True)`
+  - `auth_service.py` 中 `datetime.utcnow()` 改用 `datetime.now(timezone.utc)`
+- 测试基线最终落点：126 passed, 4 skipped，零 deprecation warning
@@ -0,0 +1,10 @@
+# 2026-09 之前 STATUS 早段历史（归档）
+
+> 文档定位：**[../STATUS.md](../STATUS.md) 顶部精简后，2026-09-17 之前条目的完整副本**。
+> 2026-09-17 及之后的批次（批次 0–4 + 后续专项 + 2026-09-21 inventory 服务下沉 + 2026-09-22 schema/datetime 弃用清零）以摘要形式保留在 [../STATUS.md](../STATUS.md) 顶部，详细流水见 [2026-09_governance_batches.md](2026-09_governance_batches.md)。
+
+---
+
+> 2026-09-02（**模块化收口 + 文档主骨架建立（基线条目）**：代码侧完成 moldinsight 技术债治理——安全收口（debug/history 权限补齐、任务访问控制收紧）、静默失败修复（`detect-undercuts` 基于真实 shape 重建）、OCC 超时后 executor 重建防毒化全队列、后台任务统一分派、Redis 任务状态改 Hash 原子更新、完成态任务视图缓存、导出缓存与持久化收口、旧入口与死代码删除、Generator 公共接口提取 + 契约测试；详见 [TECH_DEBT.md](../TECH_DEBT.md) §2。结构侧完成 `src/entrypoints/` 三入口拆分（moldinsight / inventory / unified）、`shared` 平台能力集中、前端独立 `frontend/` 工程。文档侧建立 `STATUS / ARCHITECTURE / ROADMAP / TECH_DEBT / DEPLOYMENT` 主骨架，README 收敛为唯一导航入口，历史材料迁入 [archive/](README.md)。**测试基线**：本地 pip 环境 **47 passed, 1 skipped**（pythonocc 缺失自动 skip）；moldinsight conda + OCC 环境 **88 passed**。inventory 侧少量既有 deprecation warnings 不影响通过。）
+
+> 此前：2026-09-01（**文档体系专项整理启动**：明确「README 只做导航、每类信息单一归属、历史材料进 archive」的文档治理原则；建立 deployment/ 主题目录与 archive/ 归档目录；部署文档收口为 DEPLOYMENT（入口）+ deployment/LINUX_SETUP（操作）+ deployment/DEPLOY_PORT / PORT_CONFIG（端口补充）三层。）
@@ -25,6 +25,8 @@
 - [MOLD_ERP_ANALYSIS_REPORT.md](MOLD_ERP_ANALYSIS_REPORT.md)
 - [ZERO_FINISHED_INVENTORY_CERTIFICATE.md](ZERO_FINISHED_INVENTORY_CERTIFICATE.md)
 - [CONFLUENCE_ARCHIVE_STRUCTURE.md](CONFLUENCE_ARCHIVE_STRUCTURE.md)
+- [2026-09_governance_batches.md](2026-09_governance_batches.md)：2026-09 设计审查批次 0–4 + 后续专项的完整实施流水账（[../TECH_DEBT.md](../TECH_DEBT.md) 与 [../STATUS.md](../STATUS.md) 仅保留摘要）
+- [2026-09_status_history.md](2026-09_status_history.md)：[../STATUS.md](../STATUS.md) 顶部精简后，2026-09-17 之前条目的完整副本
 - [topics/ai/](topics/ai/)：已迁移的 AI 相关专题历史材料
 - [topics/performance/](topics/performance/)：已迁移的性能专题历史材料
 - [topics/aluminum-foam/](topics/aluminum-foam/)：已迁移的铝泡沫专题历史材料
@@ -33,7 +33,17 @@
        <div class="result-card result-card-highlight" style="cursor: pointer;" @click="selectScheme(selectedScheme?.scheme_id)">
          <div class="summary-header">
            <h3>推荐方案</h3>
-            <t-tag theme="primary">{{ selectedScheme?.title || selectedScheme?.scheme_id || '方案待定' }}</t-tag>
+            <div class="tag-row">
+              <t-tag theme="primary">{{ selectedScheme?.title || selectedScheme?.scheme_id || '方案待定' }}</t-tag>
+              <t-tag
+                v-if="currentAxisHint"
+                theme="success"
+                variant="light"
+                :title="`历史 ${currentAxisHint.sample_count} 次相似产品反馈：采纳 ${currentAxisHint.adopted_count} / 拒绝 ${currentAxisHint.rejected_count}`"
+              >
+                📚 历史经验 {{ currentAxisHint.sample_count }} 条
+              </t-tag>
+            </div>
          </div>
          <div class="info-list">
            <div class="info-item">
@@ -126,6 +136,15 @@
        <t-button type="default" size="small" @click="estimateCost" :loading="state.costLoading" title="估算模具造价与单件成本">
          💰 成本估算
        </t-button>
+        <t-button
+          v-if="canGiveFeedback"
+          type="default"
+          size="small"
+          @click="openFeedbackDialog"
+          title="老师傅经验反馈：标记采纳 / 建议调整 / 拒绝，下一次同指纹产品分析将自动应用"
+        >
+          👍 老师傅反馈
+        </t-button>
      </div>

      <div id="preview-3d" v-if="selectedHtmlFile" class="viewer-section viewer-section-hero">
@@ -535,6 +554,18 @@
      </div>
      </div>
    </t-loading>
+
+    <HumanFeedbackDialog
+      v-model:visible="state.feedbackDialogVisible"
+      :task-id="(route.params.taskId as string)"
+      :scheme-id="selectedScheme?.scheme_id || ''"
+      :scheme-axis="selectedScheme?.axis || 'Z'"
+      :scheme-title="selectedScheme?.title || selectedScheme?.scheme_id || ''"
+      :fingerprint="state.hintsFingerprint"
+      :score-at-submit="selectedScheme?.score"
+      :confidence-at-submit="selectedScheme?.confidence_score"
+      @submitted="onFeedbackSubmitted"
+    />
  </div>
 </template>

@@ -543,8 +574,10 @@ import { reactive, computed, onMounted } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 import { useAppStore } from '@/stores/app'
 import { apiRequest } from '@/shared/api'
+import { moldinsightApi } from '@/shared/api-client'
 import { handleApiError, addNotification } from '@/shared/notification'
 import { formatDateTime, formatNumber } from '@/shared/utils'
+import HumanFeedbackDialog from './components/HumanFeedbackDialog.vue'

 const route = useRoute()
 const router = useRouter()
@@ -573,9 +606,12 @@ interface Scheme {
  summary?: string
  reason?: string
  score?: number
-  score_breakdown?: { manufacturability?: number; parting_quality?: number }
+  confidence_score?: number
+  score_breakdown?: { manufacturability?: number; parting_quality?: number; human_hint_bonus?: number }
  mold_structure_type?: string
  offset_label?: string
+  axis?: string
+  method?: string
  cavity_data?: CavityData
  key_info?: KeyInfo
  html_file?: string
@@ -724,6 +760,18 @@ const state = reactive({
  costLoading: false,
  costError: '',
  costResult: null as CostEstimate | null,
+  // D17 Human-in-Loop：老师傅经验反馈
+  feedbackDialogVisible: false,
+  hintsFingerprint: {} as Record<string, string>,
+  hints: [] as Array<{
+    scheme_axis: string
+    adopted_count: number
+    rejected_count: number
+    adjust_count: number
+    confidence: number
+    weight: number
+    sample_count: number
+  }>,
 })

 const camSteelOptions = [
@@ -777,12 +825,63 @@ const createProductFromAnalysis = async () => {
  }
 }

+// D17 Human-in-Loop：经验反馈
+const taskId = computed<string>(() => (route.params.taskId as string) || '')
+
+const hintsByAxis = computed<Record<string, (typeof state.hints)[number]>>(() => {
+  const map: Record<string, (typeof state.hints)[number]> = {}
+  for (const h of state.hints) {
+    map[h.scheme_axis] = h
+  }
+  return map
+})
+
+const currentAxisHint = computed<(typeof state.hints)[number] | undefined>(() => {
+  const axis = selectedScheme.value?.axis
+  if (!axis) return undefined
+  return hintsByAxis.value[axis]
+})
+
+const canGiveFeedback = computed(() => {
+  const u: any = appStore.user
+  if (!u) return false
+  if (u.is_superuser) return true
+  const roles = u.roles as Array<{ code: string }> | undefined
+  return !!roles?.some(r => r.code === 'process_engineer')
+})
+
+const loadExperienceHints = async () => {
+  if (!taskId.value) return
+  try {
+    const data = await moldinsightApi.getExperienceHints(taskId.value)
+    state.hints = (data.hints || []) as typeof state.hints
+    state.hintsFingerprint = data.fingerprint || {}
+  } catch (e) {
+    // 不阻塞主流程：拉取失败时静默退化（按钮仍可点击，新反馈走 POST 写入）
+    console.warn('拉取经验 hints 失败', e)
+  }
+}
+
+const openFeedbackDialog = () => {
+  if (!selectedScheme.value?.scheme_id) {
+    addNotification('当前方案未确定，无法反馈', 'error')
+    return
+  }
+  state.feedbackDialogVisible = true
+}
+
+const onFeedbackSubmitted = async () => {
+  addNotification('反馈已生效，正在刷新经验角标', 'success')
+  await loadExperienceHints()
+}
+
 onMounted(() => {
  if (!appStore.user) {
    router.push('/login')
    return
  }
  loadTask()
+  loadExperienceHints()
 })

 const getPriorityText = (priority: string) => {
@@ -0,0 +1,184 @@
+<template>
+  <t-dialog
+    :visible="visible"
+    @update:visible="(v: boolean) => emit('update:visible', v)"
+    header="老师傅经验反馈"
+    :close-on-overlay-click="true"
+    width="540px"
+  >
+    <div v-if="schemeTitle" class="context-block">
+      <div class="context-row">
+        <span class="context-label">方案</span>
+        <span class="context-value">{{ schemeTitle }}</span>
+      </div>
+      <div v-if="hasFingerprint" class="context-row">
+        <span class="context-label">产品指纹</span>
+        <span class="context-value">{{ formatFingerprint() }}</span>
+      </div>
+      <div class="context-row">
+        <span class="context-label">本次应用</span>
+        <span class="context-value hint-meta">写后即被下次同指纹分析消费（D17 闭环）</span>
+      </div>
+    </div>
+
+    <t-form label-width="80px">
+      <t-form-item label="反馈">
+        <t-radio-group v-model="form.feedback_status">
+          <t-radio-button value="adopted">✅ 采纳</t-radio-button>
+          <t-radio-button value="adjust">✏️ 建议调整</t-radio-button>
+          <t-radio-button value="rejected">✕ 拒绝</t-radio-button>
+        </t-radio-group>
+      </t-form-item>
+
+      <t-form-item v-if="form.feedback_status === 'adjust'" label="调整建议">
+        <t-textarea
+          v-model="form.adjust_suggestion"
+          placeholder="具体怎么调？（如：分型面偏上 0.5mm / 增加滑块位置 / 改水路直径）"
+          :maxlength="2000"
+          :autosize="{ minRows: 2, maxRows: 4 }"
+        />
+      </t-form-item>
+
+      <t-form-item label="原因">
+        <t-textarea
+          v-model="form.feedback_reason"
+          placeholder="为什么这样判断？（可选，便于团队理解）"
+          :maxlength="2000"
+          :autosize="{ minRows: 2, maxRows: 4 }"
+        />
+      </t-form-item>
+    </t-form>
+
+    <template #footer>
+      <t-button theme="default" @click="cancel" :disabled="submitting">取消</t-button>
+      <t-button theme="primary" :loading="submitting" @click="submit">提交反馈</t-button>
+    </template>
+  </t-dialog>
+</template>
+
+<script setup lang="ts">
+import { reactive, ref, watch, computed } from 'vue'
+import { moldinsightApi } from '@/shared/api-client'
+import { addNotification } from '@/shared/notification'
+
+interface Props {
+  visible: boolean
+  taskId: string
+  schemeId: string
+  schemeAxis: string
+  schemeTitle: string
+  fingerprint: Record<string, string>
+  scoreAtSubmit?: number
+  confidenceAtSubmit?: number
+}
+
+const props = defineProps<Props>()
+const emit = defineEmits<{
+  (e: 'update:visible', v: boolean): void
+  (e: 'submitted'): void
+}>()
+
+interface FeedbackForm {
+  feedback_status: 'adopted' | 'adjust' | 'rejected'
+  feedback_reason: string
+  adjust_suggestion: string
+}
+
+const form = reactive<FeedbackForm>({
+  feedback_status: 'adopted',
+  feedback_reason: '',
+  adjust_suggestion: '',
+})
+
+const submitting = ref(false)
+
+const hasFingerprint = computed(() => {
+  return Boolean(props.fingerprint && Object.keys(props.fingerprint).length > 0)
+})
+
+watch(
+  () => props.visible,
+  (v) => {
+    if (v) {
+      // 打开时重置表单
+      form.feedback_status = 'adopted'
+      form.feedback_reason = ''
+      form.adjust_suggestion = ''
+    }
+  }
+)
+
+function cancel() {
+  emit('update:visible', false)
+}
+
+function formatFingerprint(): string {
+  const f = props.fingerprint || {}
+  const items = [
+    f.bbox_aspect,
+    f.volume_bucket,
+    f.face_bucket,
+    f.material_family,
+    f.is_foam,
+  ].filter(Boolean)
+  return items.join(' / ') || '—'
+}
+
+async function submit() {
+  if (!props.taskId || !props.schemeId) {
+    addNotification('任务或方案标识缺失', 'error')
+    return
+  }
+  submitting.value = true
+  try {
+    await moldinsightApi.submitExperienceFeedback(props.taskId, {
+      scheme_id: props.schemeId,
+      feedback_status: form.feedback_status,
+      feedback_reason: form.feedback_reason || undefined,
+      adjust_suggestion:
+        form.feedback_status === 'adjust' ? form.adjust_suggestion || undefined : undefined,
+      score_at_submit: typeof props.scoreAtSubmit === 'number' ? props.scoreAtSubmit : undefined,
+      confidence_at_submit:
+        typeof props.confidenceAtSubmit === 'number'
+          ? props.confidenceAtSubmit
+          : undefined,
+    })
+    addNotification('反馈已提交，下次同指纹产品分析将自动应用', 'success')
+    emit('submitted')
+    emit('update:visible', false)
+  } catch (e: any) {
+    addNotification(e?.message || '反馈提交失败', 'error')
+  } finally {
+    submitting.value = false
+  }
+}
+</script>
+
+<style scoped>
+.context-block {
+  background: var(--bg-secondary, #f5f7fa);
+  padding: 12px 14px;
+  border-radius: 6px;
+  margin-bottom: 16px;
+  border: 1px solid var(--border-color, #e7e7e7);
+}
+.context-row {
+  display: flex;
+  gap: 12px;
+  font-size: 0.9rem;
+  line-height: 1.7;
+}
+.context-label {
+  color: var(--text-secondary, #888);
+  min-width: 70px;
+}
+.context-value {
+  color: var(--text-primary, #333);
+  font-weight: 500;
+}
+.hint-meta {
+  font-weight: 400;
+  color: var(--text-secondary, #888);
+  font-size: 0.85rem;
+}
+</style>
@@ -403,4 +403,47 @@ export const moldinsightApi = {
      body: JSON.stringify(data),
    })
  },
+
+  // D17 Human-in-Loop：老师傅经验反馈（写入即消费闭环）
+  getExperienceHints(taskId: string) {
+    return apiRequest<{
+      task_id: string
+      stp_file_id: number
+      material_name: string
+      is_foam: boolean
+      fingerprint: Record<string, string>
+      hints: Array<{
+        scheme_axis: string
+        adopted_count: number
+        rejected_count: number
+        adjust_count: number
+        confidence: number
+        weight: number
+        sample_count: number
+      }>
+    }>(`/api/tasks/${taskId}/experience-hints`)
+  },
+
+  submitExperienceFeedback(
+    taskId: string,
+    data: {
+      scheme_id: string
+      feedback_status: 'adopted' | 'adjust' | 'rejected'
+      feedback_reason?: string
+      adjust_suggestion?: string
+      confidence_at_submit?: number
+      score_at_submit?: number
+    }
+  ) {
+    return apiRequest<{
+      id: number
+      scheme_id: string
+      scheme_axis: string
+      feedback_status: string
+      created_at: string
+    }>(`/api/tasks/${taskId}/experience-feedback`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+    })
+  },
 }
@@ -0,0 +1,93 @@
+"""add experience_feedback
+
+Human-in-Loop 闭环（D17，2026-09）：老师傅对系统推荐方案给出'采纳 / 调整 / 拒绝'
+反馈，按'产品指纹 + 工艺参数'为索引跨任务匹配；下次同指纹产品分析自动消费。
+- 新增 experience_feedback 表（方案级反馈）
+- 跨模块裸 FK（user_id / processing_task_id / stp_file_id）
+- 复合索引 (stp_file_id, scheme_axis, feedback_status) 用于按方向聚合采纳计数
+- GIN 索引（PG only）用于 fingerprint JSON 字段检索
+
+Revision ID: b7d1f4a92c3e
+Revises: a3f8c2d91e47
+Create Date: 2026-09-22
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'b7d1f4a92c3e'
+down_revision: Union[str, Sequence[str], None] = 'a3f8c2d91e47'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        'experience_feedback',
+        sa.Column('id', sa.Integer(), nullable=False),
+        sa.Column('processing_task_id', sa.Integer(), nullable=False),
+        sa.Column('stp_file_id', sa.Integer(), nullable=False),
+        sa.Column('scheme_id', sa.String(length=64), nullable=False),
+        sa.Column('scheme_axis', sa.String(length=1), nullable=False),
+        sa.Column('scheme_method', sa.String(length=50), nullable=True),
+        sa.Column('feedback_status', sa.String(length=20), nullable=False),
+        sa.Column('feedback_reason', sa.Text(), nullable=True),
+        sa.Column('adjust_suggestion', sa.Text(), nullable=True),
+        sa.Column('process_params_snapshot', sa.JSON(), nullable=True),
+        sa.Column('fingerprint', sa.JSON(), nullable=False),
+        sa.Column('confidence_at_submit', sa.Float(), nullable=True),
+        sa.Column('score_at_submit', sa.Float(), nullable=True),
+        sa.Column('user_id', sa.Integer(), nullable=False),
+        sa.Column('role_code', sa.String(length=50), nullable=False),
+        sa.Column('created_at', sa.DateTime(), nullable=True),
+        sa.Column('expires_at', sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint('id'),
+        sa.ForeignKeyConstraint(
+            ['processing_task_id'], ['processing_tasks.id'], ondelete='CASCADE'
+        ),
+        sa.ForeignKeyConstraint(
+            ['stp_file_id'], ['stp_files.id'], ondelete='CASCADE'
+        ),
+        sa.ForeignKeyConstraint(
+            ['user_id'], ['users.id'], ondelete='RESTRICT'
+        ),
+    )
+    op.create_index(op.f('ix_experience_feedback_id'), 'experience_feedback', ['id'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_processing_task_id'), 'experience_feedback', ['processing_task_id'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_stp_file_id'), 'experience_feedback', ['stp_file_id'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_scheme_id'), 'experience_feedback', ['scheme_id'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_feedback_status'), 'experience_feedback', ['feedback_status'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_user_id'), 'experience_feedback', ['user_id'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_created_at'), 'experience_feedback', ['created_at'], unique=False)
+    op.create_index(op.f('ix_experience_feedback_expires_at'), 'experience_feedback', ['expires_at'], unique=False)
+    op.create_index(
+        op.f('ix_experience_feedback_stp_axis_status'),
+        'experience_feedback',
+        ['stp_file_id', 'scheme_axis', 'feedback_status'],
+        unique=False,
+    )
+    # GIN 索引（PG only）：fingerprint JSON 字段 jsonb_path_query 类查询
+    if op.get_bind().dialect.name == 'postgresql':
+        op.execute(
+            "CREATE INDEX ix_experience_feedback_fingerprint_gin "
+            "ON experience_feedback USING GIN (fingerprint)"
+        )
+
+
+def downgrade() -> None:
+    if op.get_bind().dialect.name == 'postgresql':
+        op.execute("DROP INDEX IF EXISTS ix_experience_feedback_fingerprint_gin")
+    op.drop_index(op.f('ix_experience_feedback_stp_axis_status'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_expires_at'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_created_at'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_user_id'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_feedback_status'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_scheme_id'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_stp_file_id'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_processing_task_id'), table_name='experience_feedback')
+    op.drop_index(op.f('ix_experience_feedback_id'), table_name='experience_feedback')
+    op.drop_table('experience_feedback')
@@ -27,6 +27,7 @@ ROUTE_MODULES = [
    ("加工", "moldinsight.api.machining_router", False),
    ("导出", "moldinsight.api.export_router", False),
    ("铝价", "moldinsight.api.aluminum_price_routes", False),
+    ("老师傅经验反馈", "moldinsight.api.experience_feedback_router", False),  # D17 Human-in-Loop
    # 调试端点会 dump 全量任务数据，仅 DEBUG 模式注册（双重防线：还需登录）
    ("调试", "moldinsight.api.debug_router", True),
 ]
@@ -0,0 +1,199 @@
+"""老师傅经验反馈 API：D17 Human-in-Loop 闭环。
+
+端点：
+- POST /api/tasks/{task_id}/experience-feedback  提交方案级反馈
+- GET  /api/tasks/{task_id}/experience-hints     拉取同指纹历史 hints 摘要
+
+权限：
+- 写入：Depends(get_current_active_user) + ensure_task_access + 行内 has_permission
+- 读取：Depends(get_current_active_user) + ensure_task_access（所有登录用户可看）
+
+Pydantic 模型写在路由文件内（项目硬规则，shared/models/schemas.py 不扩张）。
+"""
+from datetime import datetime
+from typing import Dict, Any, List, Literal, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.database.database import get_db_session
+from shared.models.identity import User
+from shared.services.auth_service import get_current_active_user
+from shared.utils.logger import get_logger
+
+from moldinsight.services.experience_feedback_service import (
+    ExperienceFeedbackService,
+    compute_fingerprint,
+)
+from moldinsight.services.task_query_service import TaskQueryService
+from moldinsight.models import ExperienceFeedback, ProcessingTask, GeometryData
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+
+
+# ── Pydantic 请求 / 响应模型（写在路由文件内，硬规则）──
+
+class ExperienceFeedbackCreate(BaseModel):
+    """老师傅方案级反馈请求体。"""
+
+    scheme_id: str = Field(..., min_length=1, max_length=64)
+    feedback_status: Literal["adopted", "adjust", "rejected"]
+    feedback_reason: Optional[str] = Field(None, max_length=2000)
+    adjust_suggestion: Optional[str] = Field(None, max_length=2000)
+    confidence_at_submit: Optional[float] = Field(None, ge=0.0, le=1.0)
+    score_at_submit: Optional[float] = Field(None, ge=0.0, le=100.0)
+
+
+class ExperienceFeedbackResponse(BaseModel):
+    """反馈写入响应。"""
+
+    id: int
+    scheme_id: str
+    scheme_axis: str
+    feedback_status: str
+    created_at: datetime
+
+
+class ExperienceHintItem(BaseModel):
+    """同指纹历史 hints 摘要（按 scheme_axis 聚合）。"""
+
+    scheme_axis: str
+    adopted_count: int
+    rejected_count: int
+    adjust_count: int
+    confidence: float
+    weight: float
+    sample_count: int
+
+
+class ExperienceHintsResponse(BaseModel):
+    """GET /experience-hints 响应。"""
+
+    task_id: str
+    stp_file_id: int
+    material_name: str
+    is_foam: bool
+    fingerprint: Dict[str, str]
+    hints: List[ExperienceHintItem]
+
+
+# ── 端点 ──
+
+@router.post(
+    "/tasks/{task_id}/experience-feedback",
+    response_model=ExperienceFeedbackResponse,
+)
+async def submit_feedback(
+    task_id: str,
+    body: ExperienceFeedbackCreate,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user),
+):
+    """提交方案级反馈。
+
+    权限：登录用户 + 任务归属 + feedback_experience_hint。
+    写入后由路由 commit（D9 边界）+ invalidate_task_view（task_view 60s TTL 失效）。
+    """
+    # 1. 任务归属校验（与 task_router / design_router 同一约定）
+    await TaskQueryService.ensure_task_access(db_session, task_id, current_user.id)
+
+    # 2. 权限校验：行内 has_permission（identity.py:38 全仓首次调用）
+    if not current_user.has_permission("feedback_experience_hint"):
+        raise HTTPException(403, "需要工艺工程师或管理员权限")
+
+    # 3. 写反馈（仅 flush，D9 边界由本路由 commit）
+    feedback = await ExperienceFeedbackService().record_feedback(
+        session=db_session,
+        task_id=task_id,
+        scheme_id=body.scheme_id,
+        feedback_status=body.feedback_status,
+        feedback_reason=body.feedback_reason,
+        adjust_suggestion=body.adjust_suggestion,
+        user=current_user,
+        confidence_at_submit=body.confidence_at_submit,
+        score_at_submit=body.score_at_submit,
+        process_params_snapshot=None,  # 路由不接管 process_params，由算法层填
+    )
+
+    try:
+        await db_session.commit()
+    except Exception as exc:
+        await db_session.rollback()
+        logger.error(f"反馈提交失败: {exc}")
+        raise HTTPException(500, "反馈提交失败")
+
+    # 4. 失效任务视图缓存（写反馈后 next view 立即反映 hints）
+    TaskQueryService.invalidate_task_view(task_id)
+
+    return ExperienceFeedbackResponse(
+        id=feedback.id,
+        scheme_id=feedback.scheme_id,
+        scheme_axis=feedback.scheme_axis,
+        feedback_status=feedback.feedback_status,
+        created_at=feedback.created_at or datetime.utcnow(),
+    )
+
+
+@router.get(
+    "/tasks/{task_id}/experience-hints",
+    response_model=ExperienceHintsResponse,
+)
+async def get_experience_hints(
+    task_id: str,
+    db_session: AsyncSession = Depends(get_db_session),
+    current_user: User = Depends(get_current_active_user),
+):
+    """拉取该任务的同指纹历史 hints 摘要。
+
+    权限：登录用户 + 任务归属。组织知识对所有人可见（不要求工艺工程师权限）。
+    """
+    # 1. 任务归属校验
+    row = await TaskQueryService.ensure_task_access(db_session, task_id, current_user.id)
+    _, stp_file = row
+
+    # 2. 取 material / is_foam
+    pt_row = await db_session.execute(
+        select(ProcessingTask).where(ProcessingTask.task_id == task_id)
+    )
+    processing_task = pt_row.scalar_one_or_none()
+    params = (processing_task.parameters if processing_task else None) or {}
+    material_name = str(params.get("material") or "ABS")
+    is_foam = bool(params.get("is_foam_material", False))
+
+    # 3. 计算 fingerprint（用于回显 + 与 record_feedback 用同一函数）
+    geo_row = await db_session.execute(
+        select(GeometryData).where(GeometryData.stp_file_id == stp_file.id)
+    )
+    geo = geo_row.scalar_one_or_none()
+    geometry_summary: Dict[str, Any] = {}
+    if geo is not None:
+        geometry_summary = {
+            "volume": geo.volume,
+            "bounding_box": {
+                "min": geo.bounding_box_min,
+                "max": geo.bounding_box_max,
+            },
+            "topology_faces": geo.topology_faces,
+        }
+    fingerprint = compute_fingerprint(geometry_summary, material_name, is_foam)
+
+    # 4. 拉 hints 聚合
+    hints = await ExperienceFeedbackService().list_hints_for_task(
+        session=db_session,
+        stp_file_id=stp_file.id,
+        material_name=material_name,
+        is_foam=is_foam,
+    )
+
+    return ExperienceHintsResponse(
+        task_id=task_id,
+        stp_file_id=stp_file.id,
+        material_name=material_name,
+        is_foam=is_foam,
+        fingerprint=fingerprint,
+        hints=[ExperienceHintItem(**h) for h in hints],
+    )
@@ -30,6 +30,7 @@ class MultiSchemeMoldPlanner:
        is_foam_material: bool = False,
        max_schemes: int = 3,
        process_params: Optional[Dict[str, Any]] = None,
+        hints: Optional[Dict[str, Dict[str, Any]]] = None,
    ) -> Dict[str, Any]:
        generator = mold_generator_registry.get_by_type("aluminum_foam" if is_foam_material else "injection")
        generator.set_material(material["name"])
@@ -37,10 +38,12 @@ class MultiSchemeMoldPlanner:

        analysis = generator.analyze_product_geometry(shape)
        analysis["axis_normal_stats"] = self._collect_axis_normal_stats(generator, shape)
+        # D17 Human-in-Loop 闭环：把老师傅经验 hints 注入候选方向生成
        candidates = self.candidate_generator.generate_candidates(
            analysis=analysis,
            is_foam_material=is_foam_material,
            max_candidates=max_schemes,
+            hints=hints,
        )

        schemes = []
@@ -62,7 +65,8 @@ class MultiSchemeMoldPlanner:
        if not schemes:
            raise ValueError("未能生成任何可用分模方案")

-        scored_schemes = self.scheme_scorer.score_schemes(schemes)[:max_schemes]
+        # D17：hints 透传到评分器，权重轴方向评分加成
+        scored_schemes = self.scheme_scorer.score_schemes(schemes, hints=hints)[:max_schemes]
        export_shapes = {}
        for idx, scheme in enumerate(scored_schemes, start=1):
            scheme["raw_scheme_id"] = scheme.get("scheme_id")
@@ -80,6 +84,7 @@ class MultiSchemeMoldPlanner:
            "global_summary": {
                "scheme_count": len(scored_schemes),
                "recommended_reason": best_scheme.get("summary", ""),
+                "applied_hints": hints or {},  # D17：给前端展示"本次应用了哪几条经验"
            },
        }

@@ -121,6 +121,9 @@ def _op_generate_cavity(payload):
    plan_result 里携带的 _export_shapes（TopoDS 对象）无法跨进程，子进程直接
    经 CADExporter 落盘为持久化 STEP，返回文件 manifest——与旧 _persist_step_exports
    产物结构一致，主进程原样存入 export_artifacts。
+
+    D17 Human-in-Loop：payload 顶层 experience_hints 透传给 planner.generate_plan
+    让同指纹历史老师傅反馈影响本次分模评分。payload 普通 dict 透传，pickle 安全。
    """
    parser = _cached("parser", _get_parser)
    planner = _cached("planner", _get_planner)
@@ -130,6 +133,7 @@ def _op_generate_cavity(payload):
        material=payload["material"],
        is_foam_material=payload.get("is_foam_material", False),
        process_params=payload.get("process_params"),
+        hints=payload.get("experience_hints") or {},
    )
    export_shapes = plan_result.pop("_export_shapes", {}) or {}
    export_manifest = _persist_export_shapes(payload, export_shapes)
@@ -1,4 +1,4 @@
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional


 class PartingCandidateGenerator:
@@ -15,10 +15,31 @@ class PartingCandidateGenerator:
        analysis: Dict[str, Any],
        is_foam_material: bool = False,
        max_candidates: int = 3,
+        hints: Optional[Dict[str, Dict[str, Any]]] = None,
    ) -> List[Dict[str, Any]]:
        bbox_dims = analysis.get("bounding_box", {}).get("dimensions", [0, 0, 0])

        axis_metrics = self._build_axis_metrics(bbox_dims, analysis, is_foam_material)
+
+        # D17 Human-in-Loop 闭环：老师傅采纳多的 axis 优先级加成。
+        # hints 结构：{axis: {"weight": 0.0-1.0, "sample_count": int, ...}}；
+        # 由 ExperienceFeedbackService.list_hints_for_task 聚合后产出。
+        if hints:
+            for axis_metric in axis_metrics:
+                axis = axis_metric["axis"]
+                hint = hints.get(axis)
+                if not hint:
+                    continue
+                weight = float(hint.get("weight", 0.0))
+                sample_count = int(hint.get("sample_count", 0))
+                # 上限 +20 分（weight=1.0 时）；weight 仅正值，不"扣分"老算法。
+                axis_metric["priority_score"] = axis_metric["priority_score"] + weight * 20.0
+                # sample_count 足够 + weight 强信号 → method 标签升级为"经验驱动"
+                if sample_count >= 2 and weight >= 0.5:
+                    axis_metric["method"] = "human_experience_primary"
+                    axis_metric["human_hint_weight"] = weight
+                    axis_metric["human_hint_sample_count"] = sample_count
+
        axis_order = [item["axis"] for item in sorted(
            axis_metrics,
            key=lambda item: item["priority_score"],
@@ -5,10 +5,15 @@ import re
 class PartingSchemeScorer:
    """对候选分模方案打分并排序。"""

-    def score_schemes(self, schemes: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def score_schemes(
+        self,
+        schemes: List[Dict[str, Any]],
+        *,
+        hints: Optional[Dict[str, Dict[str, Any]]] = None,
+    ) -> List[Dict[str, Any]]:
        scored = []
        for scheme in schemes:
-            score_breakdown = self._score_scheme(scheme)
+            score_breakdown = self._score_scheme(scheme, hints=hints)
            undercut_priority_bonus = self._build_undercut_priority_bonus(scheme, score_breakdown)
            total_score = round(
                score_breakdown["manufacturability"] * 0.25
@@ -16,6 +21,7 @@ class PartingSchemeScorer:
                + score_breakdown["parting_quality"] * 0.15
                + score_breakdown["machining_cost"] * 0.15
                + score_breakdown["risk"] * 0.10
+                + score_breakdown.get("human_hint_bonus", 0.0)
                + undercut_priority_bonus,
                2,
            )
@@ -44,7 +50,12 @@ class PartingSchemeScorer:
            scheme["title"] = "推荐方案" if rank == 1 else f"备选方案 {rank}"
        return scored

-    def _score_scheme(self, scheme: Dict[str, Any]) -> Dict[str, float]:
+    def _score_scheme(
+        self,
+        scheme: Dict[str, Any],
+        *,
+        hints: Optional[Dict[str, Dict[str, Any]]] = None,
+    ) -> Dict[str, float]:
        cavity_data = scheme.get("cavity_data", {})
        key_info = scheme.get("key_info", {})
        candidate_priority = float(scheme.get("priority_score", 60.0))
@@ -125,14 +136,48 @@ class PartingSchemeScorer:
            risk_base += 4.0
        risk = max(35.0, risk_base)

+        human_hint_bonus = PartingSchemeScorer._compute_human_hint_bonus(scheme, hints)
+
        return {
            "manufacturability": round(manufacturability, 2),
            "undercut_complexity": round(undercut_complexity, 2),
            "parting_quality": round(parting_quality, 2),
            "machining_cost": round(machining_cost, 2),
            "risk": round(risk, 2),
+            "human_hint_bonus": human_hint_bonus,
        }

+    @staticmethod
+    def _compute_human_hint_bonus(
+        scheme: Dict[str, Any],
+        hints: Optional[Dict[str, Dict[str, Any]]],
+    ) -> float:
+        """D17 Human-in-Loop：老师傅经验加权（写入即消费）。
+
+        设计要点：
+        - weight ∈ [0, 1] 由 history aggregation 算（adopted-rejected）/ total；仅正值
+        - bonus 上限 +12（与 undercut_priority_bonus 同量级），避免单条反馈过权重
+        - sample_count < 2 时 bonus × 0.5（信号不足折半）
+        - axis 解析优先级：scheme.parting.axis → scheme.axis → 默认 Z
+        """
+        if not hints:
+            return 0.0
+        parting = scheme.get("parting", {}) if isinstance(scheme.get("parting"), dict) else {}
+        axis = (
+            parting.get("axis")
+            or scheme.get("axis")
+            or "Z"
+        )
+        hint = hints.get(axis) or {}
+        weight = float(hint.get("weight", 0.0))
+        if weight <= 0:
+            return 0.0
+        sample_count = int(hint.get("sample_count", 0))
+        bonus = weight * 12.0
+        if sample_count < 2:
+            bonus *= 0.5
+        return round(bonus, 2)
+
    @staticmethod
    def _build_undercut_priority_bonus(
        scheme: Dict[str, Any],
@@ -14,6 +14,7 @@ from moldinsight.models.stp_analysis import (
    DesignRecommendation,
    AnalysisMetrics,
 )
+from moldinsight.models.experience_feedback import ExperienceFeedback

 __all__ = [
    "STPFile",
@@ -25,4 +26,5 @@ __all__ = [
    "FeatureDetection",
    "DesignRecommendation",
    "AnalysisMetrics",
+    "ExperienceFeedback",
 ]
@@ -0,0 +1,91 @@
+"""moldinsight 域模型：老师傅经验反馈表。
+
+Human-in-Loop 闭环（D17，2026-09）：老师傅对系统推荐方案给出"采纳 / 调整 / 拒绝"
+反馈，按"产品指纹 + 工艺参数"为索引跨任务匹配；下次同指纹产品分析自动消费
+（OCC worker payload 透传 → MultiSchemeMoldPlanner → PartingSchemeScorer 加成）。
+
+跨模块桥接只保留裸 FK，不建 ORM relationship（base.py 约定）：
+- processing_task_id -> processing_tasks.id
+- stp_file_id -> stp_files.id
+- user_id -> users.id
+
+写入 feedback 时由 service 层填充 fingerprint JSON（bbox_aspect / volume_bucket /
+face_bucket / undercut_class / material_family / is_foam）。fingerprint 是跨任务
+匹配的索引列（PG 下有 GIN 索引支持 jsonb_path_query 类查询）。
+"""
+from sqlalchemy import Column, Integer, String, Text, DateTime, JSON, Float, ForeignKey, Index
+from sqlalchemy.sql import func
+
+from shared.models.base import Base
+
+
+class ExperienceFeedback(Base):
+    """老师傅经验反馈：方案级整体反馈 + 跨任务指纹匹配。
+
+    关键字段：
+    - feedback_status: 'adopted' / 'adjust' / 'rejected'
+    - fingerprint: 跨任务匹配键，结构见 moldinsight.services.experience_feedback_service
+    - expires_at: 90 天 TTL；写新反馈时同 stp_file_id 整体续期（D17 衰减机制）
+    """
+    __tablename__ = "experience_feedback"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    # ── 任务归属（跨模块裸 FK，CASCADE 随任务 / 文件清理）──
+    processing_task_id = Column(
+        Integer,
+        ForeignKey("processing_tasks.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    stp_file_id = Column(
+        Integer,
+        ForeignKey("stp_files.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+
+    # ── 方案标识 ──
+    scheme_id = Column(String(64), nullable=False, index=True)
+    scheme_axis = Column(String(1), nullable=False)
+    scheme_method = Column(String(50), nullable=True)
+
+    # ── 反馈主体 ──
+    feedback_status = Column(String(20), nullable=False, index=True)
+    feedback_reason = Column(Text, nullable=True)
+    adjust_suggestion = Column(Text, nullable=True)
+
+    # ── 上下文快照（用于回放）──
+    process_params_snapshot = Column(JSON, nullable=True)
+    fingerprint = Column(JSON, nullable=False)
+    confidence_at_submit = Column(Float, nullable=True)
+    score_at_submit = Column(Float, nullable=True)
+
+    # ── 审计（user_id RESTRICT：禁止级联删，保留审计归因）──
+    user_id = Column(
+        Integer,
+        ForeignKey("users.id", ondelete="RESTRICT"),
+        nullable=False,
+        index=True,
+    )
+    role_code = Column(String(50), nullable=False)
+
+    # ── 时间戳与衰减 ──
+    created_at = Column(DateTime, default=func.now(), index=True)
+    expires_at = Column(DateTime, nullable=True, index=True)
+
+    __table_args__ = (
+        Index(
+            "ix_experience_feedback_stp_axis_status",
+            "stp_file_id",
+            "scheme_axis",
+            "feedback_status",
+        ),
+    )
+
+    def __repr__(self) -> str:
+        return (
+            f"<ExperienceFeedback(id={self.id}, stp_file_id={self.stp_file_id}, "
+            f"scheme_id='{self.scheme_id}', axis='{self.scheme_axis}', "
+            f"status='{self.feedback_status}')>"
+        )
@@ -0,0 +1,394 @@
+"""老师傅经验反馈服务：D17 Human-in-Loop 闭环。
+
+三层使用：
+1. `record_feedback` — 路由层 POST 调用；写入 ExperienceFeedback；同 stp_file_id
+   整体续期（D17 衰减机制）；只 flush，由路由 commit（D9 边界）。
+2. `list_hints_for_task` — 路由层 GET 调用；按 stp_file_id + material_family +
+   is_foam 锚定，聚合返回前端 ResultView 用 hints 摘要。
+3. `resolve_for_process_params` — ProcessingService 调用；返回 OCC worker payload
+   用的 hints dict，OCC 子进程透传给 MultiSchemeMoldPlanner。
+"""
+from datetime import datetime, timedelta, timezone
+from typing import Dict, Any, List, Optional
+
+from sqlalchemy import select, update, or_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.models.identity import User, Role, UserRole
+from shared.utils.logger import get_logger
+from moldinsight.models import (
+    ExperienceFeedback,
+    ProcessingTask,
+    STPFile,
+    GeometryData,
+    MoldCavityData,
+)
+
+logger = get_logger(__name__)
+
+FEEDBACK_TTL_DAYS = 90
+
+
+def compute_fingerprint(
+    geometry_data: Optional[dict],
+    material_name: str,
+    is_foam: bool,
+) -> Dict[str, str]:
+    """计算产品指纹（跨任务匹配键）。
+
+    分桶策略见 plan §5.1：
+    - bbox_aspect: cube/compact/slab/elongated/long_bar
+    - volume_bucket: xs/s/m/l/xl（mm³ → cm³）
+    - face_bucket: simple/normal/complex/dense
+    - undercut_class: none/mild/moderate/heavy
+    - material_family: foam/abs/pp/pa/other（粗粒度，避免材料名变化导致匹配失效）
+    - is_foam: "true"/"false"
+    """
+    geo = geometry_data or {}
+    dims = geo.get("bounding_box", {}).get("dimensions") or [0, 0, 0]
+    sorted_dims = sorted(dims or [0, 0, 0])
+    if sorted_dims[0] <= 0:
+        ratio = 1.0
+    else:
+        ratio = sorted_dims[1] / sorted_dims[0]
+
+    if ratio < 1.0:
+        bbox_aspect = "cube"
+    elif ratio < 1.5:
+        bbox_aspect = "compact"
+    elif ratio < 3.0:
+        bbox_aspect = "slab"
+    elif ratio < 6.0:
+        bbox_aspect = "elongated"
+    else:
+        bbox_aspect = "long_bar"
+
+    volume_cm3 = (geo.get("volume", 0) or 0) / 1000.0
+    if volume_cm3 < 10:
+        volume_bucket = "xs"
+    elif volume_cm3 < 100:
+        volume_bucket = "s"
+    elif volume_cm3 < 500:
+        volume_bucket = "m"
+    elif volume_cm3 < 2000:
+        volume_bucket = "l"
+    else:
+        volume_bucket = "xl"
+
+    face_count = (
+        geo.get("topology_faces", 0)
+        or geo.get("topology", {}).get("faces", 0)
+        or 0
+    )
+    if face_count < 100:
+        face_bucket = "simple"
+    elif face_count < 500:
+        face_bucket = "normal"
+    elif face_count < 2000:
+        face_bucket = "complex"
+    else:
+        face_bucket = "dense"
+
+    undercut_count = geo.get("undercut_count", 0) or 0
+    if undercut_count == 0:
+        undercut_class = "none"
+    elif undercut_count < 4:
+        undercut_class = "mild"
+    elif undercut_count < 9:
+        undercut_class = "moderate"
+    else:
+        undercut_class = "heavy"
+
+    mat_lower = (material_name or "").lower()
+    if "al" in mat_lower and "si" in mat_lower:
+        material_family = "foam"
+    elif "abs" in mat_lower:
+        material_family = "abs"
+    elif "pp" in mat_lower:
+        material_family = "pp"
+    elif "pa" in mat_lower:
+        material_family = "pa"
+    else:
+        material_family = "other"
+
+    return {
+        "bbox_aspect": bbox_aspect,
+        "volume_bucket": volume_bucket,
+        "face_bucket": face_bucket,
+        "undercut_class": undercut_class,
+        "material_family": material_family,
+        "is_foam": "true" if is_foam else "false",
+    }
+
+
+class ExperienceFeedbackService:
+    """老师傅经验反馈：写入 / 同指纹 hints 摘要 / OCC worker 用 hints 解析。"""
+
+    def __init__(self) -> None:
+        # 显式无依赖：与 processing_service / task_storage_service 范式一致
+        pass
+
+    async def record_feedback(
+        self,
+        session: AsyncSession,
+        *,
+        task_id: str,
+        scheme_id: str,
+        feedback_status: str,
+        feedback_reason: Optional[str],
+        adjust_suggestion: Optional[str],
+        user: User,
+        confidence_at_submit: Optional[float] = None,
+        score_at_submit: Optional[float] = None,
+        process_params_snapshot: Optional[Dict[str, Any]] = None,
+    ) -> ExperienceFeedback:
+        """写入方案级反馈。仅 flush，由路由 commit（D9 边界）。
+
+        同时同 stp_file_id 整体续期（expires_at = now() + 90d），
+        "写入即消费"的语义保证新反馈立刻进入有效集。
+        """
+        if feedback_status not in ("adopted", "adjust", "rejected"):
+            raise ValueError(f"feedback_status 非法: {feedback_status}")
+
+        # 1. 找 task + stp_file
+        row = await session.execute(
+            select(ProcessingTask, STPFile)
+            .join(STPFile, ProcessingTask.stp_file_id == STPFile.id)
+            .where(ProcessingTask.task_id == task_id)
+        )
+        row = row.first()
+        if not row:
+            raise ValueError(f"任务不存在: {task_id}")
+        processing_task, stp_file = row
+
+        # 2. 解析 material_name + is_foam_material
+        params = processing_task.parameters or {}
+        material_name = str(params.get("material") or "ABS")
+        is_foam_material = bool(params.get("is_foam_material", False))
+
+        # 3. 取 geometry_data / cavity_data 计算 fingerprint
+        geometry_summary: Dict[str, Any] = {}
+        geo_row = await session.execute(
+            select(GeometryData).where(GeometryData.stp_file_id == stp_file.id)
+        )
+        geo = geo_row.scalar_one_or_none()
+        if geo is not None:
+            geometry_summary = {
+                "volume": geo.volume,
+                "bounding_box": {
+                    "min": geo.bounding_box_min,
+                    "max": geo.bounding_box_max,
+                },
+                "topology_faces": geo.topology_faces,
+            }
+
+        cavity_row = await session.execute(
+            select(MoldCavityData).where(MoldCavityData.stp_file_id == stp_file.id)
+        )
+        cavity = cavity_row.scalar_one_or_none()
+        if cavity is not None:
+            ki = cavity.cavity_key_info or {}
+            side_actions = (
+                ki.get("quality_considerations") if isinstance(ki, dict) else None
+            ) or {}
+            if isinstance(side_actions, dict):
+                geometry_summary["undercut_count"] = side_actions.get("undercut_count", 0) or 0
+
+        fingerprint = compute_fingerprint(geometry_summary, material_name, is_foam_material)
+
+        # 4. 找 scheme 的 axis + method（从 cavity_key_info.candidate_schemes）
+        scheme_axis = "Z"
+        scheme_method: Optional[str] = None
+        if cavity is not None:
+            ki = cavity.cavity_key_info or {}
+            candidate_schemes = ki.get("candidate_schemes") if isinstance(ki, dict) else None
+            if isinstance(candidate_schemes, list):
+                for cs in candidate_schemes:
+                    if isinstance(cs, dict) and cs.get("scheme_id") == scheme_id:
+                        scheme_axis = (
+                            cs.get("axis")
+                            or cs.get("parting_axis")
+                            or "Z"
+                        )
+                        scheme_method = cs.get("method") or cs.get("scheme_method")
+                        break
+
+        # 5. 取用户角色（显式 JOIN 查询，避免 user.roles 在跨 session 下 lazy load 失败）
+        role_codes = await self._fetch_user_role_codes(session, user.id)
+        if getattr(user, "is_superuser", False):
+            role_code = "admin"
+        elif role_codes:
+            role_code = role_codes[0]
+        else:
+            role_code = "user"
+
+        # 6. 写 ExperienceFeedback
+        now = datetime.now(timezone.utc)
+        new_ttl = now + timedelta(days=FEEDBACK_TTL_DAYS)
+        feedback = ExperienceFeedback(
+            processing_task_id=processing_task.id,
+            stp_file_id=stp_file.id,
+            scheme_id=scheme_id,
+            scheme_axis=str(scheme_axis)[:1],
+            scheme_method=scheme_method,
+            feedback_status=feedback_status,
+            feedback_reason=feedback_reason,
+            adjust_suggestion=adjust_suggestion,
+            process_params_snapshot=process_params_snapshot,
+            fingerprint=fingerprint,
+            confidence_at_submit=confidence_at_submit,
+            score_at_submit=score_at_submit,
+            user_id=user.id,
+            role_code=role_code,
+            expires_at=new_ttl,
+        )
+        session.add(feedback)
+        await session.flush()
+
+        # 7. 同 stp_file_id 整体续期（D17 衰减：仅刷新过期 / NULL 行）
+        await session.execute(
+            update(ExperienceFeedback)
+            .where(
+                ExperienceFeedback.stp_file_id == stp_file.id,
+                or_(
+                    ExperienceFeedback.expires_at.is_(None),
+                    ExperienceFeedback.expires_at < now,
+                ),
+            )
+            .values(expires_at=new_ttl)
+        )
+        await session.flush()
+        return feedback
+
+    async def list_hints_for_task(
+        self,
+        session: AsyncSession,
+        *,
+        stp_file_id: int,
+        material_name: str,
+        is_foam: bool,
+        limit: int = 10,
+    ) -> List[Dict[str, Any]]:
+        """同指纹历史采纳摘要，给前端 ResultView 用。
+
+        排除 expires_at < now() 的过期反馈；按 material_family + is_foam 锚定；
+        按 scheme_axis 聚合（adopted/rejected/adjust 计数 + 加权 confidence）。
+        """
+        now = datetime.now(timezone.utc)
+        is_foam_str = "true" if is_foam else "false"
+        mat_lower = (material_name or "").lower()
+        if "al" in mat_lower and "si" in mat_lower:
+            material_family = "foam"
+        elif "abs" in mat_lower:
+            material_family = "abs"
+        elif "pp" in mat_lower:
+            material_family = "pp"
+        elif "pa" in mat_lower:
+            material_family = "pa"
+        else:
+            material_family = "other"
+
+        rows = await session.execute(
+            select(ExperienceFeedback)
+            .where(
+                ExperienceFeedback.stp_file_id == stp_file_id,
+                or_(
+                    ExperienceFeedback.expires_at.is_(None),
+                    ExperienceFeedback.expires_at > now,
+                ),
+            )
+            .order_by(ExperienceFeedback.created_at.desc())
+            .limit(limit * 4)
+        )
+        feedbacks = rows.scalars().all()
+
+        axis_summary: Dict[str, Dict[str, Any]] = {}
+        for fb in feedbacks:
+            fp = fb.fingerprint or {}
+            # 锚定：material_family + is_foam 必须一致
+            if fp.get("material_family") != material_family:
+                continue
+            if fp.get("is_foam") != is_foam_str:
+                continue
+            axis = fb.scheme_axis or "Z"
+            summary = axis_summary.setdefault(axis, {
+                "scheme_axis": axis,
+                "adopted_count": 0,
+                "rejected_count": 0,
+                "adjust_count": 0,
+                "sample_count": 0,
+            })
+            summary["sample_count"] += 1
+            if fb.feedback_status == "adopted":
+                summary["adopted_count"] += 1
+            elif fb.feedback_status == "rejected":
+                summary["rejected_count"] += 1
+            elif fb.feedback_status == "adjust":
+                summary["adjust_count"] += 1
+
+        result: List[Dict[str, Any]] = []
+        for axis, s in axis_summary.items():
+            total = s["adopted_count"] + s["rejected_count"] + s["adjust_count"]
+            if total == 0:
+                continue
+            confidence = (s["adopted_count"] - s["rejected_count"]) / max(total, 1)
+            confidence = max(-1.0, min(1.0, confidence))
+            weight = max(0.0, confidence)  # weight 仅正向上有效（不"扣分"老算法）
+            s["confidence"] = round(confidence, 3)
+            s["weight"] = round(weight, 3)
+            result.append(s)
+
+        result.sort(key=lambda x: (-x["weight"], -x["sample_count"]))
+        return result[:limit]
+
+    @staticmethod
+    async def _fetch_user_role_codes(session: AsyncSession, user_id: int) -> List[str]:
+        """显式 JOIN 拿用户角色 codes，避免 user.roles 在跨 session 下 detached lazy load 失败。
+
+        测试场景下 user 是从一个 session 取出传到另一个 session，访问 user.roles 会触发
+        DetachedInstanceError；生产场景下也以显式查询更稳（不依赖 ORM relationship 配置）。
+        """
+        rows = await session.execute(
+            select(Role.code)
+            .join(UserRole, UserRole.role_id == Role.id)
+            .where(UserRole.user_id == user_id)
+        )
+        return [row[0] for row in rows.all()]
+
+    async def resolve_for_process_params(
+        self,
+        session: AsyncSession,
+        *,
+        task_id: str,
+        process_params: Dict[str, Any],
+        bucket_hint: Optional[Dict[str, str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """返回 OCC worker payload 用的 hints。
+
+        按 fingerprint bucket 找同指纹最近 N 条采纳，每条
+        {scheme_axis, weight, sample_count, summary}，传给 PartingSchemeScorer
+        加成和 PartingCandidateGenerator 优先级加成。
+        """
+        row = await session.execute(
+            select(ProcessingTask, STPFile)
+            .join(STPFile, ProcessingTask.stp_file_id == STPFile.id)
+            .where(ProcessingTask.task_id == task_id)
+        )
+        row = row.first()
+        if not row:
+            return []
+        processing_task, stp_file = row
+        params = processing_task.parameters or {}
+        material_name = str(params.get("material") or "ABS")
+        is_foam = bool(params.get("is_foam_material", False))
+
+        return await self.list_hints_for_task(
+            session,
+            stp_file_id=stp_file.id,
+            material_name=material_name,
+            is_foam=is_foam,
+        )
+
+
+# 模块级单例（与 processing_service / task_storage_service 范式一致）
+experience_feedback_service = ExperienceFeedbackService()
@@ -223,8 +223,13 @@ class ProcessingService:

            stage_started = time.perf_counter()
            plan_result, export_artifacts = await self._step_generate_cavity(
-                file_path, selected_material, is_foam_material, process_params,
-                task_id, timeout=timeout_seconds,
+                db_session,
+                file_path,
+                selected_material,
+                is_foam_material,
+                process_params,
+                task_id,
+                timeout=timeout_seconds,
            )
            stage_timings["generate_cavity"] = round(time.perf_counter() - stage_started, 3)
            # 方案 B：各方案形状的持久化 STEP 已由子进程导出并返回 manifest（export_artifacts），
@@ -529,14 +534,46 @@ class ProcessingService:
        return mesh_result

    async def _step_generate_cavity(
-        self, file_path: str, selected_material: dict, is_foam_material: bool,
-        process_params: Dict[str, Any], task_id: str, timeout: float = 600,
+        self,
+        db_session: AsyncSession,
+        file_path: str,
+        selected_material: dict,
+        is_foam_material: bool,
+        process_params: Dict[str, Any],
+        task_id: str,
+        timeout: float = 600,
    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
        """生成多方案分模结果（方案 B：子进程内完成分模 + 方案形状 STEP 导出）。

        D8：型腔是任务的核心产出，生成失败必须让任务 failed——
        异常直接向编排层传播。返回 (plan_result, export_manifest)。
+
+        D17 Human-in-Loop 闭环：解析同指纹历史 hints（list of {scheme_axis, weight, sample_count, ...}），
+        装进 OCC worker payload，让子进程内的 planner/candidate_generator/scheme_scorer 加成。
+        hints 解析失败不阻塞主流程（logger.warning 后视为空），保证已有任务不退化。
        """
+        # D17：拉取同指纹老师傅经验（写入即消费）
+        experience_hints: List[Dict[str, Any]] = []
+        try:
+            from moldinsight.services.experience_feedback_service import (
+                experience_feedback_service,
+            )
+            experience_hints = await experience_feedback_service.resolve_for_process_params(
+                session=db_session,
+                task_id=task_id,
+                process_params=process_params or {},
+            )
+            if experience_hints:
+                logger.info(
+                    f"D17 Human-in-Loop：注入 {len(experience_hints)} 条经验"
+                    f"到 task={task_id} 的分模方案"
+                )
+        except Exception as hints_err:
+            logger.warning(
+                f"D17 hints 解析失败，回退到无 hints 模式: {hints_err}"
+            )
+            experience_hints = []
+
        result = await self.run_occ(
            "generate_cavity",
            {
@@ -546,6 +583,7 @@ class ProcessingService:
                "is_foam_material": is_foam_material,
                "process_params": process_params,
                "export_out_dir": os.path.abspath(self.cad_exporter.output_dir),
+                "experience_hints": experience_hints,  # D17 payload 通道
            },
            timeout=timeout,
        )
@@ -65,55 +65,86 @@ DEFAULT_PERMISSIONS = [
    {"code": "view_users", "name": "查看用户", "module": "admin"},
    {"code": "manage_users", "name": "管理用户", "module": "admin"},
    {"code": "manage_roles", "name": "管理角色", "module": "admin"},
+    # D17 Human-in-Loop：老师傅经验反馈
+    {"code": "view_experience_feedback", "name": "查看老师傅反馈", "module": "moldinsight"},
+    {"code": "feedback_experience_hint", "name": "提交方案级反馈", "module": "moldinsight"},
+    {"code": "manage_experience_feedback", "name": "管理老师傅反馈", "module": "moldinsight"},
 ]

 DEFAULT_ROLES = [
-    {"code": "admin", "name": "管理员", "description": "系统管理员，拥有所有权限", "is_system": True, "permissions": ["view_dashboard", "view_moldinsight", "upload_file", "view_history", "view_inventory", "manage_inventory", "view_products", "manage_products", "view_suppliers", "manage_suppliers", "view_customers", "manage_customers", "view_finance", "manage_receipts", "manage_payments", "void_finance_transaction", "view_users", "manage_users", "manage_roles"]},
+    {"code": "admin", "name": "管理员", "description": "系统管理员，拥有所有权限", "is_system": True, "permissions": ["view_dashboard", "view_moldinsight", "upload_file", "view_history", "view_inventory", "manage_inventory", "view_products", "manage_products", "view_suppliers", "manage_suppliers", "view_customers", "manage_customers", "view_finance", "manage_receipts", "manage_payments", "void_finance_transaction", "view_users", "manage_users", "manage_roles", "view_experience_feedback", "feedback_experience_hint", "manage_experience_feedback"]},
    {"code": "user", "name": "普通用户", "description": "普通用户，可使用模具分析和查看库存", "is_system": False, "permissions": ["view_dashboard", "view_moldinsight", "upload_file", "view_history", "view_inventory", "view_products", "view_suppliers", "view_customers", "view_finance", "manage_receipts", "manage_payments"]},
    {"code": "viewer", "name": "只读用户", "description": "只读用户，只能查看数据", "is_system": False, "permissions": ["view_dashboard", "view_moldinsight", "view_history", "view_inventory", "view_products", "view_suppliers", "view_customers", "view_finance"]},
+    # D17 Human-in-Loop：工艺工程师角色——可查看 + 提交老师傅反馈
+    {"code": "process_engineer", "name": "工艺工程师", "description": "工艺工程师，可查看 + 提交老师傅经验反馈", "is_system": False, "permissions": ["view_dashboard", "view_moldinsight", "upload_file", "view_history", "view_experience_feedback", "feedback_experience_hint"]},
 ]


 async def init_permissions(session):
-    """初始化权限"""
+    """初始化权限（按 code 补登：已存在跳过，缺失新增）
+
+    设计要点（D17 修复）：
+    - 旧实现 `if existing_perms: return` 会让既存 DB 启动期漏掉新增权限码
+    - 改为按 code 比对：已存在的 permission 保留 id（避免 FK 引用失效），
+      缺失的新增；这样后续 DEFAULT_PERMISSIONS 追加的项也能在升级时落到既存 DB
+    """
    result = await session.execute(select(Permission))
-    existing_perms = result.scalars().all()
+    existing_perms = {p.code: p for p in result.scalars().all()}

-    if existing_perms:
-        logger.info("权限已初始化")
-        return
-    
-    perm_map = {}
+    perm_map = {p.code: p.id for p in existing_perms.values()}
+    new_count = 0
    for perm_data in DEFAULT_PERMISSIONS:
+        if perm_data["code"] in existing_perms:
+            continue
        perm = Permission(**perm_data)
        session.add(perm)
        await session.flush()
        perm_map[perm.code] = perm.id
+        new_count += 1

-    logger.info(f"创建了 {len(DEFAULT_PERMISSIONS)} 个权限")
+    if not existing_perms:
+        logger.info(f"创建了 {len(DEFAULT_PERMISSIONS)} 个权限")
+    elif new_count:
+        logger.info(f"补登了 {new_count} 个权限（既有 DB 升级）")
+    else:
+        logger.info("权限已初始化（无新增）")
    return perm_map


 async def init_roles(session, perm_map):
-    """初始化角色"""
+    """初始化角色（按 code 补登：已存在跳过，缺失新建 + 完整绑定 permissions）
+
+    设计要点（D17 修复）：
+    - 旧实现 `if existing_roles: return` 会让既存 DB 启动期漏掉新角色
+    - 改为按 code 比对：已存在的角色不重置其 RolePermission 绑定
+      （避免重建关联破坏 user / role 关系），缺失的角色按 DEFAULT_ROLES 完整创建
+    """
    result = await session.execute(select(Role))
-    existing_roles = result.scalars().all()
-    
-    if existing_roles:
-        logger.info("角色已初始化")
-        return
+    existing_roles = {r.code: r for r in result.scalars().all()}

+    new_count = 0
    for role_data in DEFAULT_ROLES:
-        perm_ids = [perm_map[code] for code in role_data.pop("permissions")]
+        code = role_data["code"]
+        if code in existing_roles:
+            continue
+        perm_codes = role_data.pop("permissions")
        role = Role(**role_data)
        session.add(role)
        await session.flush()
-        
-        for perm_id in perm_ids:
+        for perm_code in perm_codes:
+            perm_id = perm_map.get(perm_code)
+            if perm_id is None:
+                continue
            rp = RolePermission(role_id=role.id, permission_id=perm_id)
            session.add(rp)
+        new_count += 1

-    logger.info(f"创建了 {len(DEFAULT_ROLES)} 个角色")
+    if not existing_roles:
+        logger.info(f"创建了 {len(DEFAULT_ROLES)} 个角色")
+    elif new_count:
+        logger.info(f"补登了 {new_count} 个角色（既有 DB 升级）")
+    else:
+        logger.info("角色已初始化（无新增）")


 async def create_admin_user(session):
@@ -164,6 +164,28 @@ async def seeded_db(async_engine):
        yield session


+def pytest_addoption(parser):
+    """D13 部署侧契约：仅在显式 --run-lockfile-check 时启用锁文件存在性断言。"""
+    parser.addoption(
+        "--run-lockfile-check",
+        action="store_true",
+        default=False,
+        help="启用 D13 锁文件部署侧契约测试（CI 镜像构建 job 使用）",
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    """默认跳过 D13 部署侧契约（仓库侧单测不应被尚未落地的锁文件阻断）。"""
+    if config.getoption("--run-lockfile-check", default=False):
+        return
+    skip_marker = pytest.mark.skip(
+        reason="D13 部署侧契约：默认 skip；CI 镜像构建 job 需传入 --run-lockfile-check 启用"
+    )
+    for item in items:
+        if "test_lockfile_generation" in item.nodeid:
+            item.add_marker(skip_marker)
+
+
@pytest.fixture(scope="function")
 async def client(async_engine, seeded_db):
    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
@@ -0,0 +1,417 @@
+"""D17 Human-in-Loop 闭环：算法接缝回归测试。
+
+覆盖：
+- PartingCandidateGenerator：hints 注入 axis 优先级、method 标签
+- PartingSchemeScorer：score_breakdown 新增 human_hint_bonus、total_score 加成
+- MultiSchemeMoldPlanner：hints 透传、global_summary.applied_hints
+- processing_service：OCC payload 装配 experience_hints（OCC-gated）
+
+注：PartingCandidateGenerator / PartingSchemeScorer / MultiSchemeMoldPlanner 本身
+不直接 import OCC（OCC shape 留 lazy 在 occ_worker），可在无 OCC 环境直接测试。
+processing_service.py 通过 occ_process_pool 间接 import OCC，那两个测试 OCC-gated。
+"""
+from typing import Any, Dict, List
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+# OCC 条件探测（仅 processing_service 测试需要）
+try:
+    import OCC  # noqa: F401
+    HAS_OCC = True
+except ImportError:
+    HAS_OCC = False
+
+OCC_GATED = pytest.mark.skipif(
+    not HAS_OCC,
+    reason="D17 payload 测试依赖 processing_service（含 occ_process_pool），"
+           "OCC 缺失时无法 import；项目硬规则 OCC-gated",
+)
+
+
+# ── PartingCandidateGenerator 测试 ──
+
+def _make_analysis(dims=(80.0, 60.0, 40.0), volume=50000.0):
+    """构造 PartingCandidateGenerator 期望的 analysis dict。"""
+    return {
+        "bounding_box": {
+            "dimensions": list(dims),
+            "min": [0.0, 0.0, 0.0],
+            "max": list(dims),
+            "center": [d / 2 for d in dims],
+        },
+        "volume": volume,
+        "inertia_matrix": [[1000.0, 0.0, 0.0], [0.0, 800.0, 0.0], [0.0, 0.0, 600.0]],
+        "axis_normal_stats": {"X": 35.0, "Y": 35.0, "Z": 30.0},
+    }
+
+
+def test_parting_candidate_generator_no_hints_default():
+    """hints=None 应保持原有 3 轴评分（向后兼容）。"""
+    from moldinsight.core.parting_candidate_generator import PartingCandidateGenerator
+
+    gen = PartingCandidateGenerator()
+    candidates = gen.generate_candidates(
+        analysis=_make_analysis(),
+        is_foam_material=False,
+        max_candidates=3,
+    )
+    assert len(candidates) == 3
+    # 没有 human_experience_primary 标签
+    for c in candidates:
+        assert c["method"] != "human_experience_primary"
+
+
+def test_parting_candidate_generator_applies_hints_axis_weight():
+    """hints={X: weight=0.9, sample_count=3} → X 轴 method 标签升级、priority_score +18。"""
+    from moldinsight.core.parting_candidate_generator import PartingCandidateGenerator
+
+    gen = PartingCandidateGenerator()
+    candidates_no = gen.generate_candidates(
+        analysis=_make_analysis(),
+        is_foam_material=False,
+        max_candidates=3,
+        hints=None,
+    )
+    x_no = next(c for c in candidates_no if c["axis"] == "X")
+    x_no_score = x_no["priority_score"]
+
+    candidates_with = gen.generate_candidates(
+        analysis=_make_analysis(),
+        is_foam_material=False,
+        max_candidates=3,
+        hints={
+            "X": {"weight": 0.9, "sample_count": 3, "adopted_count": 5, "rejected_count": 1},
+        },
+    )
+    x_with = next(c for c in candidates_with if c["axis"] == "X")
+    # priority_score 提升 18 分（0.9 × 20）
+    assert abs(x_with["priority_score"] - (x_no_score + 18.0)) < 0.01
+    # method 标签变为 human_experience_primary
+    assert x_with["method"] == "human_experience_primary"
+
+
+def test_parting_candidate_generator_low_sample_count_no_method_upgrade():
+    """sample_count=1（信号不足）时 method 标签不升级。"""
+    from moldinsight.core.parting_candidate_generator import PartingCandidateGenerator
+
+    gen = PartingCandidateGenerator()
+    candidates = gen.generate_candidates(
+        analysis=_make_analysis(),
+        is_foam_material=False,
+        max_candidates=3,
+        hints={
+            "Y": {"weight": 0.8, "sample_count": 1, "adopted_count": 1, "rejected_count": 0},
+        },
+    )
+    y = next(c for c in candidates if c["axis"] == "Y")
+    # sample_count < 2 → method 不升级（但 priority_score 仍加成 16 分）
+    assert y["method"] != "human_experience_primary"
+
+
+# ── PartingSchemeScorer 测试 ──
+
+def _make_scheme(axis: str = "X", method: str = "geometric_primary", score: float = 60.0):
+    """构造 PartingSchemeScorer 期望的 scheme dict。"""
+    return {
+        "scheme_id": f"scheme_{axis}",
+        "axis": axis,
+        "parting": {"axis": axis},
+        "method": method,
+        "priority_score": score,
+        "cavity_data": {
+            "mold_cavities": {
+                "cavity": {"vertex_count": 100},
+                "core": {"vertex_count": 100},
+            },
+            "quality_checks": {
+                "undercut_regions": [],
+                "side_actions": {
+                    "summary": {"total_mechanism_count": 0, "complexity": "simple"},
+                    "slider_mechanisms": [],
+                    "lifter_mechanisms": [],
+                    "undercut_analysis": {"total_undercut_area": 0},
+                },
+            },
+            "manufacturing_info": {
+                "estimated_mold_size": {"length": 200, "width": 200, "height": 200},
+                "estimated_clamping_force": "150-300 吨",
+            },
+        },
+        "key_info": {
+            "quality_considerations": {"warpage_risk": "low"},
+            "geometric_characteristics": {"wall_thickness_range": "1.5 - 3.0 mm"},
+        },
+    }
+
+
+def test_scheme_scorer_no_hints_no_bonus_field():
+    """hints=None → score_breakdown 不含 human_hint_bonus（保持默认结构）。"""
+    from moldinsight.core.parting_scheme_scorer import PartingSchemeScorer
+
+    scorer = PartingSchemeScorer()
+    scored = scorer.score_schemes([_make_scheme("X")])
+    # hints=None 时 bonus=0，但仍写入 score_breakdown 以让前端 diff 稳定
+    assert "human_hint_bonus" in scored[0]["score_breakdown"]
+    assert scored[0]["score_breakdown"]["human_hint_bonus"] == 0.0
+
+
+def test_scheme_scorer_human_hint_bonus_added():
+    """hints={Y: weight=1.0, sample_count=5} → score_breakdown.human_hint_bonus == 12.0。"""
+    from moldinsight.core.parting_scheme_scorer import PartingSchemeScorer
+
+    scorer = PartingSchemeScorer()
+    hints = {"Y": {"weight": 1.0, "sample_count": 5, "adopted_count": 5, "rejected_count": 0}}
+
+    # 同一方案：有 hints vs 无 hints，total_score 差应等于 human_hint_bonus
+    scored_with = scorer.score_schemes([_make_scheme("Y")], hints=hints)
+    scored_without = scorer.score_schemes([_make_scheme("Y")], hints=None)
+
+    assert scored_with[0]["score_breakdown"]["human_hint_bonus"] == 12.0
+    delta = scored_with[0]["score"] - scored_without[0]["score"]
+    assert abs(delta - 12.0) < 0.01
+
+
+def test_scheme_scorer_low_sample_count_halves_bonus():
+    """sample_count=1 → bonus ×0.5 = 6.0（信号不足折半）。"""
+    from moldinsight.core.parting_scheme_scorer import PartingSchemeScorer
+
+    scorer = PartingSchemeScorer()
+    hints = {"Z": {"weight": 1.0, "sample_count": 1, "adopted_count": 1, "rejected_count": 0}}
+
+    scored = scorer.score_schemes([_make_scheme("Z")], hints=hints)
+    assert scored[0]["score_breakdown"]["human_hint_bonus"] == 6.0
+
+
+def test_scheme_scorer_zero_weight_no_bonus():
+    """weight=0 → bonus=0（既不加分也不扣分）。"""
+    from moldinsight.core.parting_scheme_scorer import PartingSchemeScorer
+
+    scorer = PartingSchemeScorer()
+    hints = {"X": {"weight": 0.0, "sample_count": 3, "adopted_count": 0, "rejected_count": 3}}
+
+    scored = scorer.score_schemes([_make_scheme("X")], hints=hints)
+    assert scored[0]["score_breakdown"]["human_hint_bonus"] == 0.0
+
+
+# ── MultiSchemeMoldPlanner 测试（OCC-gated：直接 import OCC）──
+
+@OCC_GATED
+def test_multi_scheme_planner_passes_hints_through(monkeypatch):
+    """generate_plan(hints=...) 应透传到 candidate_generator 和 scheme_scorer。"""
+    from moldinsight.core import multi_scheme_planner
+
+    captured = {"candidate_hints": None, "scorer_hints": None}
+
+    class FakeGenerator:
+        def __init__(self):
+            self.calls = []
+
+        def set_material(self, *_):
+            pass
+
+        def apply_process_params(self, *_):
+            pass
+
+        def analyze_product_geometry(self, _shape):
+            return {
+                "bounding_box": {"dimensions": [80, 60, 40]},
+                "volume": 50000,
+                "inertia_matrix": [[1000, 0, 0], [0, 800, 0], [0, 0, 600]],
+            }
+
+    class FakePlanner:
+        def generate_candidates(self, **kwargs):
+            captured["candidate_hints"] = kwargs.get("hints")
+            return [
+                {
+                    "scheme_id": "scheme_1",
+                    "axis": "X",
+                    "direction": [1, 0, 0],
+                    "title": "推荐候选方向",
+                    "method": "geometric_primary",
+                    "priority_score": 80.0,
+                    "opening_span_mm": 40.0,
+                    "projected_area_cm2": 32.0,
+                    "reason": "test",
+                },
+            ]
+
+        def score_schemes(self, schemes, *, hints=None):
+            captured["scorer_hints"] = hints
+            for s in schemes:
+                s["score"] = 80.0
+                s["score_breakdown"] = {"human_hint_bonus": 0.0}
+            return schemes
+
+    planner_obj = multi_scheme_planner.MultiSchemeMoldPlanner.__new__(
+        multi_scheme_planner.MultiSchemeMoldPlanner
+    )
+    planner_obj.candidate_generator = FakePlanner()
+    planner_obj.scheme_scorer = FakePlanner()
+    planner_obj.candidate_generator.generate_candidates = planner_obj.candidate_generator.generate_candidates
+    planner_obj.scheme_scorer.score_schemes = planner_obj.scheme_scorer.score_schemes
+    # 用 planner_obj.candidate_generator 与 scheme_scorer 是 FakePlanner 实例，所以
+    # generator.generate_candidates 会调用 FakePlanner.generate_candidates —— 但因为同
+    # 一实例两个方法都覆盖，下面显式覆写两次：
+    planner_obj.candidate_generator = type("G", (), {
+        "generate_candidates": lambda self, **kw: (
+            captured.update({"candidate_hints": kw.get("hints")}) or
+            [{"scheme_id": "scheme_1", "axis": "X", "direction": [1,0,0],
+              "title": "推荐", "method": "geo", "priority_score": 80.0,
+              "opening_span_mm": 40.0, "projected_area_cm2": 32.0, "reason": "test"}]
+        )
+    })()
+    planner_obj.scheme_scorer = type("S", (), {
+        "score_schemes": lambda self, schemes, *, hints=None: (
+            captured.update({"scorer_hints": hints}) or
+            [{**s, "score": 80.0, "score_breakdown": {"human_hint_bonus": 0.0}} for s in schemes]
+        )
+    })()
+
+    fake_hints = {"X": {"weight": 0.9, "sample_count": 3, "adopted_count": 5, "rejected_count": 1}}
+    result = planner_obj.generate_plan(
+        shape=MagicMock(),
+        material={"name": "ABS"},
+        is_foam_material=False,
+        hints=fake_hints,
+    )
+
+    assert captured["candidate_hints"] == fake_hints, "candidate_generator 未接收 hints"
+    assert captured["scorer_hints"] == fake_hints, "scheme_scorer 未接收 hints"
+    assert result["global_summary"]["applied_hints"] == fake_hints
+
+
+@OCC_GATED
+def test_multi_scheme_planner_applied_hints_default_empty():
+    """generate_plan 不传 hints 时 global_summary.applied_hints 为空 dict。"""
+    from moldinsight.core import multi_scheme_planner
+
+    planner_obj = multi_scheme_planner.MultiSchemeMoldPlanner.__new__(
+        multi_scheme_planner.MultiSchemeMoldPlanner
+    )
+    planner_obj.candidate_generator = type("G", (), {
+        "generate_candidates": lambda self, **kw: [
+            {"scheme_id": "scheme_1", "axis": "X", "direction": [1,0,0],
+             "title": "推荐", "method": "geo", "priority_score": 80.0,
+             "opening_span_mm": 40.0, "projected_area_cm2": 32.0, "reason": "test"}
+        ]
+    })()
+    planner_obj.scheme_scorer = type("S", (), {
+        "score_schemes": lambda self, schemes, *, hints=None: (
+            [{**s, "score": 80.0, "score_breakdown": {"human_hint_bonus": 0.0}} for s in schemes]
+        )
+    })()
+
+    result = planner_obj.generate_plan(
+        shape=MagicMock(),
+        material={"name": "ABS"},
+        is_foam_material=False,
+    )
+    assert result["global_summary"]["applied_hints"] == {}
+
+
+# ── processing_service payload 装配测试（OCC-gated）──
+
+@OCC_GATED
+def test_processing_service_step_generate_cavity_includes_experience_hints(monkeypatch):
+    """_step_generate_cavity 应在 run_occ payload 中装入 experience_hints。"""
+    import asyncio
+    from moldinsight.services import processing_service
+
+    # Mock experience_feedback_service
+    fake_hints = [{"scheme_axis": "X", "weight": 0.8, "sample_count": 4,
+                   "adopted_count": 4, "rejected_count": 0}]
+    fake_ef_service = MagicMock()
+    fake_ef_service.resolve_for_process_params = AsyncMock(return_value=fake_hints)
+
+    monkeypatch.setattr(
+        processing_service, "experience_feedback_service", fake_ef_service, raising=False
+    )
+
+    # Mock run_occ 拦截 payload
+    captured_payload = {}
+    async def fake_run_occ(self, op_name, payload, timeout):
+        captured_payload["op_name"] = op_name
+        captured_payload["payload"] = payload
+        return {
+            "plan_result": {"candidate_schemes": [], "best_scheme_id": None,
+                            "global_summary": {"applied_hints": {}}},
+            "export_manifest": None,
+        }
+    monkeypatch.setattr(
+        processing_service.ProcessingService, "run_occ", fake_run_occ
+    )
+
+    # Mock cad_exporter
+    monkeypatch.setattr(
+        processing_service.ProcessingService, "__init__",
+        lambda self: setattr(self, "cad_exporter", MagicMock(output_dir="/tmp"))
+    )
+
+    svc = processing_service.ProcessingService()
+    svc.cad_exporter = MagicMock(output_dir="/tmp")
+
+    async def run():
+        await svc._step_generate_cavity(
+            db_session=MagicMock(),
+            file_path="/tmp/x.stp",
+            selected_material={"name": "ABS"},
+            is_foam_material=False,
+            process_params={"material": "ABS", "draft_angle": 2.0,
+                            "shrinkage_rate": 0.5, "parting_precision": 0.1,
+                            "cavity_match": 95},
+            task_id="task-test-1",
+            timeout=60,
+        )
+
+    asyncio.run(run())
+
+    assert captured_payload["payload"]["experience_hints"] == fake_hints
+
+
+@OCC_GATED
+def test_processing_service_step_generate_cavity_empty_hints_on_error(monkeypatch):
+    """experience_feedback_service 抛异常时 hints 应回退到空 list（不阻塞主流程）。"""
+    import asyncio
+    from moldinsight.services import processing_service
+
+    fake_ef_service = MagicMock()
+    fake_ef_service.resolve_for_process_params = AsyncMock(
+        side_effect=RuntimeError("DB down")
+    )
+
+    monkeypatch.setattr(
+        processing_service, "experience_feedback_service", fake_ef_service, raising=False
+    )
+
+    captured_payload = {}
+    async def fake_run_occ(self, op_name, payload, timeout):
+        captured_payload["payload"] = payload
+        return {
+            "plan_result": {"candidate_schemes": [], "best_scheme_id": None,
+                            "global_summary": {"applied_hints": {}}},
+            "export_manifest": None,
+        }
+    monkeypatch.setattr(
+        processing_service.ProcessingService, "run_occ", fake_run_occ
+    )
+
+    svc = processing_service.ProcessingService()
+    svc.cad_exporter = MagicMock(output_dir="/tmp")
+
+    async def run():
+        await svc._step_generate_cavity(
+            db_session=MagicMock(),
+            file_path="/tmp/x.stp",
+            selected_material={"name": "ABS"},
+            is_foam_material=False,
+            process_params={"material": "ABS"},
+            task_id="task-test-1",
+            timeout=60,
+        )
+
+    asyncio.run(run())
+
+    # 抛异常时回退到空 list，主流程继续
+    assert captured_payload["payload"]["experience_hints"] == []
@@ -0,0 +1,156 @@
+"""D17 Human-in-Loop 闭环：compute_fingerprint 分桶边界值测试。
+
+compute_fingerprint 是跨任务匹配的核心函数，纯函数，单独覆盖各分桶边界。
+D17 验收：fingerprint 字典结构稳定 + 分桶边界值与 plan §5.1 一致。
+"""
+import pytest
+
+from moldinsight.services.experience_feedback_service import compute_fingerprint
+
+
+def _geo(volume: float = 50000.0, dims=(80, 60, 40), faces: int = 250, undercuts: int = 0):
+    """构造测试用 geometry_data 字典。dims 单位 mm，volume 单位 mm³。"""
+    return {
+        "volume": volume,
+        "bounding_box": {
+            "dimensions": list(dims),
+        },
+        "topology_faces": faces,
+        "undercut_count": undercuts,
+    }
+
+
+# ── bbox_aspect 分桶（按 sorted_dims mid/min 比）──
+
+@pytest.mark.parametrize("dims,expected", [
+    # ratio = mid/min
+    ((100, 100, 100), "compact"),    # ratio=1.0 → compact（1.0 ≤ r < 1.5）
+    ((100, 130, 100), "compact"),    # ratio=1.0（去重后）
+    ((60, 80, 100), "compact"),      # ratio=1.0 → compact
+    ((40, 80, 100), "slab"),         # ratio=80/40=2.0 → slab（1.5 ≤ r < 3.0）
+    ((20, 80, 100), "elongated"),    # ratio=80/20=4.0 → elongated（3.0 ≤ r < 6.0）
+    ((10, 80, 100), "long_bar"),     # ratio=80/10=8 → long_bar（≥ 6.0）
+    ((0, 0, 0), "compact"),          # 零值默认
+])
+def test_bbox_aspect_bucket(dims, expected):
+    fp = compute_fingerprint(_geo(dims=dims), "ABS", False)
+    assert fp["bbox_aspect"] == expected, f"dims={dims} → expected {expected}, got {fp['bbox_aspect']}"
+
+
+# ── volume_bucket 分桶（mm³ → cm³，buckets: xs<10 / s<100 / m<500 / l<2000 / xl≥2000）──
+
+@pytest.mark.parametrize("volume_mm3,expected", [
+    (0, "xs"),                # 0 cm³
+    (5000, "xs"),             # 5 cm³
+    (9999, "xs"),             # 边界 9.99 cm³ → xs
+    (10000, "s"),             # 10 cm³ → s（10 ≤ v < 100）
+    (50000, "s"),             # 50 cm³
+    (99999, "s"),             # 边界 99.99 cm³
+    (100000, "m"),            # 100 cm³ → m（100 ≤ v < 500）
+    (250000, "m"),             # 250 cm³
+    (499999, "m"),            # 边界 499.99 cm³
+    (500000, "l"),            # 500 cm³ → l（500 ≤ v < 2000）
+    (1000000, "l"),            # 1000 cm³
+    (1999999, "l"),           # 边界 1999.99 cm³
+    (2000000, "xl"),          # 2000 cm³ → xl（v ≥ 2000）
+    (10000000, "xl"),          # 10000 cm³
+])
+def test_volume_bucket(volume_mm3, expected):
+    fp = compute_fingerprint(_geo(volume=volume_mm3), "ABS", False)
+    assert fp["volume_bucket"] == expected, f"volume={volume_mm3}mm³ → expected {expected}, got {fp['volume_bucket']}"
+
+
+# ── face_bucket 分桶 ──
+
+@pytest.mark.parametrize("faces,expected", [
+    (0, "simple"),           # 0 面
+    (99, "simple"),          # 边界 99
+    (100, "normal"),          # 边界 100
+    (499, "normal"),          # 边界 499
+    (500, "complex"),         # 边界 500
+    (1999, "complex"),       # 边界 1999
+    (2000, "dense"),          # 边界 2000
+    (10000, "dense"),
+])
+def test_face_bucket(faces, expected):
+    fp = compute_fingerprint(_geo(faces=faces), "ABS", False)
+    assert fp["face_bucket"] == expected, f"faces={faces} → expected {expected}, got {fp['face_bucket']}"
+
+
+# ── undercut_class 分桶 ──
+
+@pytest.mark.parametrize("undercuts,expected", [
+    (0, "none"),               # 0 → none
+    (1, "mild"),               # 1 → mild
+    (3, "mild"),                # 边界 3
+    (4, "moderate"),            # 边界 4
+    (8, "moderate"),            # 边界 8
+    (9, "heavy"),                # 边界 9
+    (50, "heavy"),
+])
+def test_undercut_class(undercuts, expected):
+    fp = compute_fingerprint(_geo(undercuts=undercuts), "ABS", False)
+    assert fp["undercut_class"] == expected, f"undercuts={undercuts} → expected {expected}, got {fp['undercut_class']}"
+
+
+# ── material_family 分桶 ──
+
+@pytest.mark.parametrize("material,expected", [
+    ("ABS", "abs"),
+    ("ABS+PC", "abs"),     # 子串匹配
+    ("PP", "pp"),
+    ("PA66", "pa"),
+    ("AlSi10Mg", "foam"),  # "al" + "si"
+    ("AlSi12", "foam"),
+    ("Aluminium Alloy", "other"),  # 只有 al 无 si
+    ("POM", "other"),
+    ("", "other"),
+])
+def test_material_family(material, expected):
+    fp = compute_fingerprint(_geo(), material, False)
+    assert fp["material_family"] == expected, f"material={material} → expected {expected}, got {fp['material_family']}"
+
+
+# ── is_foam 字段 ──
+
+@pytest.mark.parametrize("is_foam,expected", [
+    (True, "true"),
+    (False, "false"),
+])
+def test_is_foam(is_foam, expected):
+    fp = compute_fingerprint(_geo(), "ABS", is_foam)
+    assert fp["is_foam"] == expected
+
+
+# ── 字典键完整性 ──
+
+def test_fingerprint_has_all_keys():
+    fp = compute_fingerprint(_geo(), "ABS", False)
+    expected_keys = {
+        "bbox_aspect", "volume_bucket", "face_bucket",
+        "undercut_class", "material_family", "is_foam",
+    }
+    assert set(fp.keys()) == expected_keys
+
+
+# ── 空 geometry_data 容错 ──
+
+def test_empty_geometry_data_returns_safe_defaults():
+    fp = compute_fingerprint(None, "ABS", False)
+    # 不应抛异常，所有键存在且为合法 bucket 值
+    assert fp["bbox_aspect"] == "compact"
+    assert fp["volume_bucket"] == "xs"
+    assert fp["face_bucket"] == "simple"
+    assert fp["undercut_class"] == "none"
+    assert fp["material_family"] == "abs"
+    assert fp["is_foam"] == "false"
+
+
+def test_partial_geometry_data():
+    """只有 bounding_box 没有 topology_faces，应走 fallback 0。"""
+    fp = compute_fingerprint(
+        {"bounding_box": {"dimensions": [100, 100, 100]}},
+        "ABS",
+        False,
+    )
+    assert fp["face_bucket"] == "simple"   # 0 面 → simple
@@ -0,0 +1,319 @@
+"""D17 Human-in-Loop 闭环：API 契约测试。
+
+覆盖：
+- POST /api/tasks/{task_id}/experience-feedback
+    - 401（无登录态 —— 由 Depends(get_current_active_user) 处理）
+    - 403（user 角色无 feedback_experience_hint 权限）
+    - 200（admin 角色有 manage_experience_feedback 全权限）
+    - 200（process_engineer 角色有 feedback_experience_hint 权限）
+- GET /api/tasks/{task_id}/experience-hints
+    - 200 命中（同 stp_file_id 历史反馈聚合）
+    - cache invalidation（POST 写完后视图失效）
+- D9 边界：record_feedback 失败时 db 不留半成品
+"""
+import pytest
+from fastapi import FastAPI
+from httpx import AsyncClient, ASGITransport
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import configure_mappers
+
+from shared.models.base import Base
+from shared.models.identity import User, Role, Permission, RolePermission, UserRole
+from shared.services.auth_service import get_current_active_user
+from shared.database.database import get_db_session
+
+from moldinsight.api.experience_feedback_router import router as feedback_router
+from moldinsight.models import (
+    STPFile, GeometryData, MoldCavityData, ProcessingTask, ExperienceFeedback,
+)
+
+
+@pytest.fixture
+async def feedback_client(async_engine, seeded_db):
+    """构造带 experience_feedback_router 的 test app。
+
+    与 conftest.client 不同，这里我们用 seeded_db 的 user=tester，但通过依赖覆盖
+    让所有请求都以 admin 身份进（admin 是项目测试约定身份）。
+
+    关键点：override 返回的 User 必须用 selectinload 预加载 user_roles → role → role_permissions → permission，
+    否则 User.has_permission() 内部访问 self.roles 触发跨 session lazy load 失败。
+    """
+    from sqlalchemy.orm import selectinload
+
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+
+    test_app = FastAPI()
+    test_app.include_router(feedback_router)
+
+    async def override_get_db_session():
+        async with session_factory() as session:
+            yield session
+
+    async def override_get_current_active_user():
+        async with session_factory() as session:
+            result = await session.execute(
+                select(User)
+                .where(User.username == "tester")
+                .options(
+                    selectinload(User.user_roles)
+                    .selectinload(UserRole.role)
+                    .selectinload(Role.role_permissions)
+                    .selectinload(RolePermission.permission)
+                )
+            )
+            return result.scalar_one()
+
+    test_app.dependency_overrides[get_db_session] = override_get_db_session
+    test_app.dependency_overrides[get_current_active_user] = override_get_current_active_user
+
+    transport = ASGITransport(app=test_app)
+    async with AsyncClient(transport=transport, base_url="http://test") as ac:
+        yield ac
+
+    test_app.dependency_overrides.clear()
+
+
+async def _grant_permission(session, user, code):
+    """给测试 user 加指定 permission_code。
+
+    注意：User.is_superuser 是 @property（派生自 role.code == "admin"），
+    不能直接赋值；admin 权限通过给 user 关联 'admin' role 触发。
+    """
+    # 找/创建 permission
+    perm_row = await session.execute(select(Permission).where(Permission.code == code))
+    perm = perm_row.scalar_one_or_none()
+    if perm is None:
+        perm = Permission(code=code, name=code, module="moldinsight")
+        session.add(perm)
+        await session.flush()
+
+    # 找/创建 role（用 permission code 作 role code，便于复用）
+    role_row = await session.execute(select(Role).where(Role.code == code))
+    role = role_row.scalar_one_or_none()
+    if role is None:
+        role = Role(code=code, name=code, is_system=False)
+        session.add(role)
+        await session.flush()
+        rp = RolePermission(role_id=role.id, permission_id=perm.id)
+        session.add(rp)
+
+    # 关联 user（如未关联）
+    user_role_row = await session.execute(
+        select(UserRole).where(UserRole.user_id == user.id, UserRole.role_id == role.id)
+    )
+    if user_role_row.scalar_one_or_none() is None:
+        session.add(UserRole(user_id=user.id, role_id=role.id))
+    await session.commit()
+
+
+# ── POST /experience-feedback 测试 ──
+
+async def test_submit_feedback_403_without_permission(feedback_client, async_engine):
+    """tester 默认无任何权限 → 403。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    # 确保 tester 没有 admin role 也没有 feedback_experience_hint role
+    async with session_factory() as session:
+        await session.execute(
+            UserRole.__table__.delete().where(UserRole.user_id == 1)
+        )
+        await session.commit()
+
+    resp = await feedback_client.post(
+        "/tasks/task-demo-1/experience-feedback",
+        json={
+            "scheme_id": "scheme_1",
+            "feedback_status": "adopted",
+        },
+    )
+    assert resp.status_code == 403, resp.text
+    assert "工艺工程师" in resp.text
+
+
+async def test_submit_feedback_200_with_feedback_permission(feedback_client, async_engine):
+    """给 tester 授予 feedback_experience_hint → 200 + 写入经验反馈。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "feedback_experience_hint")
+
+    resp = await feedback_client.post(
+        "/tasks/task-demo-1/experience-feedback",
+        json={
+            "scheme_id": "scheme_1",
+            "feedback_status": "adopted",
+            "feedback_reason": "工艺验证 OK",
+            "confidence_at_submit": 0.85,
+            "score_at_submit": 87.5,
+        },
+    )
+    assert resp.status_code == 200, resp.text
+    body = resp.json()
+    assert body["scheme_id"] == "scheme_1"
+    assert body["feedback_status"] == "adopted"
+
+    # DB 真的写入了
+    async with session_factory() as session:
+        result = await session.execute(
+            select(ExperienceFeedback).where(ExperienceFeedback.scheme_id == "scheme_1")
+        )
+        fb = result.scalar_one()
+        assert fb.user_id == tester.id
+        assert fb.feedback_status == "adopted"
+        assert fb.role_code == "feedback_experience_hint"   # 写入时角色归因
+        assert fb.expires_at is not None
+
+
+async def test_submit_feedback_200_with_admin(feedback_client, async_engine):
+    """admin role → has_permission 走 role.code=='admin' 短路 → 200。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "admin")
+
+    resp = await feedback_client.post(
+        "/tasks/task-demo-1/experience-feedback",
+        json={
+            "scheme_id": "scheme_2",
+            "feedback_status": "rejected",
+        },
+    )
+    assert resp.status_code == 200, resp.text
+    assert resp.json()["scheme_axis"]  # 自动从 cavity_key_info 解析，缺则默认 Z
+
+
+async def test_submit_feedback_invalid_status_returns_422(feedback_client, async_engine):
+    """feedback_status 非法 → Pydantic 校验 422。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "admin")
+
+    resp = await feedback_client.post(
+        "/tasks/task-demo-1/experience-feedback",
+        json={
+            "scheme_id": "scheme_1",
+            "feedback_status": "approve",   # 非法值
+        },
+    )
+    assert resp.status_code == 422
+
+
+# ── GET /experience-hints 测试 ──
+
+async def test_get_hints_200_empty(feedback_client, async_engine):
+    """无反馈历史 → 空 hints 列表，fingerprint 回显。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "admin")
+
+    resp = await feedback_client.get("/tasks/task-demo-1/experience-hints")
+    assert resp.status_code == 200, resp.text
+    body = resp.json()
+    assert body["task_id"] == "task-demo-1"
+    assert body["stp_file_id"] == 1
+    assert body["hints"] == []
+    assert "bbox_aspect" in body["fingerprint"]
+
+
+async def test_get_hints_aggregates_by_axis(feedback_client, async_engine):
+    """写入多条反馈后 GET hints 按 axis 聚合。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "admin")
+
+    # 写入 4 条反馈，全部落在 axis="Z" 默认（无 cavity_key_info）
+    for fb in [
+        {"scheme_id": "x_1", "feedback_status": "adopted"},
+        {"scheme_id": "x_2", "feedback_status": "adopted"},
+        {"scheme_id": "x_3", "feedback_status": "rejected"},
+        {"scheme_id": "z_1", "feedback_status": "adopted"},
+    ]:
+        resp = await feedback_client.post(
+            "/tasks/task-demo-1/experience-feedback",
+            json=fb,
+        )
+        assert resp.status_code == 200, resp.text
+
+    # GET hints
+    resp = await feedback_client.get("/tasks/task-demo-1/experience-hints")
+    assert resp.status_code == 200, resp.text
+    body = resp.json()
+
+    # 无 cavity_key_info 时所有 feedback 落在 axis="Z" 默认值 → 4 条聚合
+    assert len(body["hints"]) == 1
+    h = body["hints"][0]
+    assert h["scheme_axis"] == "Z"
+    assert h["adopted_count"] == 3
+    assert h["rejected_count"] == 1
+    assert h["sample_count"] == 4
+    assert h["confidence"] == 0.5   # (3-1)/4
+
+
+async def test_submit_feedback_increments_expires_at(feedback_client, async_engine):
+    """同 stp_file_id 上写入新反馈时，旧行的 expires_at 应被续期（write-time 续期）。"""
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "admin")
+
+    # 写入第一条反馈
+    resp = await feedback_client.post(
+        "/tasks/task-demo-1/experience-feedback",
+        json={"scheme_id": "scheme_1", "feedback_status": "adopted"},
+    )
+    assert resp.status_code == 200
+
+    # 拿到第一条 expires_at
+    async with session_factory() as session:
+        first = (await session.execute(
+            select(ExperienceFeedback).where(ExperienceFeedback.scheme_id == "scheme_1")
+        )).scalar_one()
+        first_expires = first.expires_at
+        assert first_expires is not None
+
+    # 写第二条（不同 scheme_id），应触发同 stp_file 续期
+    import asyncio
+    await asyncio.sleep(0.05)
+    resp = await feedback_client.post(
+        "/tasks/task-demo-1/experience-feedback",
+        json={"scheme_id": "scheme_2", "feedback_status": "rejected"},
+    )
+    assert resp.status_code == 200
+
+    # 第一条 expires_at 应被续期（≥ 原值）
+    async with session_factory() as session:
+        first_after = (await session.execute(
+            select(ExperienceFeedback).where(ExperienceFeedback.scheme_id == "scheme_1")
+        )).scalar_one()
+        assert first_after.expires_at >= first_expires
+
+
+# ── 任务归属校验 ──
+
+async def test_submit_feedback_with_unknown_task_returns_404(feedback_client, async_engine):
+    """task_id 不存在 → ensure_task_access 返回 404（不是 500）。
+
+    D9 边界保护：service.record_feedback 永远走不到（ensure_task_access 先拦截）。
+    """
+    session_factory = async_sessionmaker(async_engine, class_=AsyncSession, expire_on_commit=False)
+    async with session_factory() as session:
+        tester = (await session.execute(select(User).where(User.username == "tester"))).scalar_one()
+        await _grant_permission(session, tester, "admin")
+
+    resp = await feedback_client.post(
+        "/tasks/non-existent-task-id/experience-feedback",
+        json={"scheme_id": "scheme_1", "feedback_status": "adopted"},
+    )
+    assert resp.status_code == 404
+    assert "不存在" in resp.text
+
+
+# ── 配置：D17 模型注册收口 ──
+
+def test_experience_feedback_registered_in_metadata():
+    """D17：experience_feedback 表已加入 Base.metadata（防止漏注册导致 ORM 不可用）。"""
+    configure_mappers()
+    assert "experience_feedback" in Base.metadata.tables
@@ -0,0 +1,105 @@
+"""D13：锁文件生成契约（部署侧硬性要求）
+
+锁文件 deploy/requirements-{base,moldinsight}.lock.txt 的存在性 + 体积下限
+是部署侧硬性要求：
+
+- 锁文件必须在 moldinsight conda 环境构建成功后落盘（见 deploy/generate_lockfiles.sh/.bat）
+- 锁文件必须以 git 跟踪方式提交，CI / 离线构建 / 生产复现部署才能直接 `pip install -r`
+- 若 lock.txt 缺失或异常空（仅镜像元数据 < 5 行），说明构建流程未走 D13 流程
+
+CI 门禁建议：
+- 仓库侧默认 pytest（`pytest tests/ -q`）**不**强制这些断言——锁文件属"部署侧产物"，
+  首次构建未完成时不应阻塞日常单测
+- 部署侧 / CI 镜像构建 job 用 `--run-lockfile-check` 显式开启本套件（见 conftest.py）
+"""
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEPLOY_DIR = REPO_ROOT / "deploy"
+
+LOCK_FILES = [
+    DEPLOY_DIR / "requirements-base.lock.txt",
+    DEPLOY_DIR / "requirements-moldinsight.lock.txt",
+]
+
+GENERATOR_SCRIPTS = [
+    DEPLOY_DIR / "generate_lockfiles.sh",
+    DEPLOY_DIR / "generate_lockfiles.bat",
+]
+
+
+def pytest_collection_modifyitems(config, items):
+    """仅在显式传入 --run-lockfile-check 时启用 D13 部署侧契约。"""
+    if not config.getoption("--run-lockfile-check", default=False):
+        skip_marker = pytest.mark.skip(
+            reason="D13 部署侧契约：默认 skip；CI 镜像构建 job 需传入 --run-lockfile-check 启用"
+        )
+        for item in items:
+            if "test_lockfile_generation" in item.nodeid:
+                item.add_marker(skip_marker)
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--run-lockfile-check",
+        action="store_true",
+        default=False,
+        help="启用 D13 锁文件部署侧契约测试（CI 镜像构建 job 使用）",
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    """仅在显式传入 --run-lockfile-check 时启用 D13 部署侧契约。
+
+    说明：本钩子保留作为冗余保护（conftest.py 已注册同名钩子），
+    即便测试单独跑 pytest tests/test_lockfile_generation.py 也能正确跳过。
+    """
+    if not config.getoption("--run-lockfile-check", default=False):
+        skip_marker = pytest.mark.skip(
+            reason="D13 部署侧契约：默认 skip；CI 镜像构建 job 需传入 --run-lockfile-check 启用"
+        )
+        for item in items:
+            item.add_marker(skip_marker)
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--run-lockfile-check",
+        action="store_true",
+        default=False,
+        help="启用 D13 锁文件部署侧契约测试（CI 镜像构建 job 使用）",
+    )
+
+
+@pytest.mark.parametrize("lock_path", LOCK_FILES)
+def test_lockfile_exists_and_is_substantive(lock_path):
+    """锁文件必须存在且非空（≥5 行 pip freeze 产物），否则部署侧契约缺失。"""
+    assert lock_path.exists(), (
+        f"缺少锁文件 {lock_path.relative_to(REPO_ROOT)}；"
+        f"请在 moldinsight conda 环境执行 deploy/generate_lockfiles.sh/.bat 后提交"
+    )
+    line_count = sum(1 for _ in lock_path.open(encoding="utf-8") if _.strip())
+    assert line_count >= 5, (
+        f"锁文件 {lock_path.relative_to(REPO_ROOT)} 体积异常（仅 {line_count} 行非空行），"
+        "可能是构建流程未走通，请重新生成"
+    )
+
+
+@pytest.mark.parametrize("script_path", GENERATOR_SCRIPTS)
+def test_lockfile_generator_script_present(script_path):
+    """锁文件生成脚本必须随仓库分发，否则新机器无法落锁。"""
+    assert script_path.exists(), (
+        f"缺少生成脚本 {script_path.relative_to(REPO_ROOT)}；"
+        "D13 流程入口文件缺失"
+    )
+
+
+def test_lockfile_dockerfile_comment_points_to_generator():
+    """Dockerfile.moldinsight 必须明确指向锁文件生成脚本。"""
+    dockerfile = (DEPLOY_DIR / "Dockerfile.moldinsight").read_text(encoding="utf-8")
+    assert "generate_lockfiles" in dockerfile, (
+        "Dockerfile.moldinsight 应在注释中指向 deploy/generate_lockfiles.sh 以引导锁文件生成流程"
+    )
@@ -1,7 +1,7 @@
-"""D3 模型拆分归属保护（批次 4，2026-09-17）。
+"""D3 模型拆分归属保护（批次 4，2026-09-17）+ D17 Human-in-Loop 闭环。

 锁定三个拆分成果：
-1. 三包模型全量注册后 mapper 可配置、31 表齐全；
+1. 三包模型全量注册后 mapper 可配置、32 表齐全（含 D17 新增 experience_feedback）；
 2. 单模块部署（inventory-only / moldinsight-only + auth）独立配置 mapper 成功——
   跨模块 ORM relationship 已清零，任何一侧不注册对方模型也能工作；
 3. 旧 shared.models.database 模块已删除且无兼容 facade（诚实原则：不留假象）。
@@ -20,6 +20,8 @@ EXPECTED_TABLES = {
    # moldinsight.models
    "stp_files", "geometry_data", "mesh_data", "html_files", "processing_tasks",
    "mold_cavity_data", "feature_detections", "design_recommendations", "analysis_metrics",
+    # D17：老师傅经验反馈（Human-in-Loop 闭环，2026-09）
+    "experience_feedback",
    # inventory.models
    "products", "product_materials", "material_price_history", "material_suppliers",
    "suppliers", "customers", "warehouses", "inventory", "stock_movements",
@@ -28,7 +30,7 @@ EXPECTED_TABLES = {
 }


-def test_full_registration_covers_all_31_tables():
+def test_full_registration_covers_all_32_tables():
    import shared.models.identity  # noqa: F401
    import moldinsight.models  # noqa: F401
    import inventory.models  # noqa: F401
Author	SHA1	Message	Date
cjw	6baa6b0d0a	docs：ARCHITECTURE / ROADMAP 同步 D17 Human-in-Loop 完成更新两个权威文档与 D17 端到端闭环对齐： - docs/ROADMAP.md §2.2 主线二"moldinsight 工程化增强"重点方向加一条 D17 已完成条目（2026-09-23~24，3 个 commit：数据 + 权限 + 写入 API / 算法接缝 + OCC payload / 前端按钮 + Dialog + 经验角标；详见 TECH_DEBT.md D17），与既有 ~~XXX~~（YYYY-MM-DD 完成）格式一致 - docs/ARCHITECTURE.md 新增 §6.4 D17 Human-in-Loop 老师傅经验反馈闭环 —— 已完成段：用 ASCII 数据流图展示老师傅点反馈按钮 → 路由层 → service 写入 → 续期衰减 → 上传新 STP 触发 resolve_for_process_params → OCC payload 透传 → planner 算法加成 → ResultView 渲染的端到端链路段内列出"硬规则遵守"（跨模块 FK 守 §5.1、OCC payload 守 occ_worker.py:7-8、D9 边界不破、init_db.py 幂等修复已落）和 "重量级约束"（weight 仅正向、sample_count<2 时 ×0.5、graceful 退化、角色门控），最后给测试基线指针放在 §6.3"文档与结构尚未完全同步"之后作为"已完成端到端闭环" 对照示例，便于新成员理解 D17 在系统中的位置文档侧仅变更，无代码改动；按 AGENTS.md §4.1 映射表，模块边界（ARCHITECTURE.md）/ 演进路线（ROADMAP.md）相关变更同步。 Co-Authored-By: Claude Code <noreply@anthropic.com>	2026-09-24 10:15:36 +08:00
cjw	483f158424	D17 批 3：前端按钮 + Dialog + 经验角标——闭环可视让老师傅能用起来：ResultView 加按钮组 + HumanFeedbackDialog 组件 + 经验角标渲染 + 接口变更三件套随批完成，admin / process_engineer 可在分析结果页标记采纳 / 建议调整 / 拒绝，下次同指纹产品分析自动消费。变更内容： - frontend/src/modules/moldinsight/components/HumanFeedbackDialog.vue（new）新组件：t-dialog + t-form + t-radio-group 三选一（采纳 / 建议调整 / 拒绝）+ t-textarea 原因 + t-textarea 调整建议（仅 adjust 模式显隐）；走 moldinsightApi.submitExperienceFeedback，提交成功后 emit 'submitted' 让父组件重新拉 hints 刷新角标；表单打开时 watch 重置；loading 态 / error 通知复用 shared/notification - frontend/src/modules/moldinsight/ResultView.vue - import moldinsightApi 与 HumanFeedbackDialog - state 增加 feedbackDialogVisible / hintsFingerprint / hints - Scheme interface 扩展 axis / confidence_score / method 顶层字段（前端 TS 类型与后端 Pydantic 字段对齐） - computed taskId / hintsByAxis / currentAxisHint（避免 undefined index TS 报错）/ canGiveFeedback（is_superuser \|\| roles 含 process_engineer） - function loadExperienceHints（onMounted + 提交后各调一次；失败静默退化，按钮仍可点）/ openFeedbackDialog / onFeedbackSubmitted - 模板： * 推荐方案卡片 summary-header 加 t-tag theme="success" variant="light" 经验角标（"📚 历史经验 N 条"，title 提示采纳/拒绝计数） * export-buttons-bar 加 👍 老师傅反馈按钮（v-if="canGiveFeedback" 角色门控；theme="default" size="small" 与既有 6 个 t-button 视觉一致） * </t-loading> 之后挂 HumanFeedbackDialog（v-model:visible + 11 个 props 透传 scheme_id / axis / fingerprint / score_at_submit / 等） - frontend/src/shared/api-client.ts moldinsightApi 加两个方法： getExperienceHints(taskId) / submitExperienceFeedback(taskId, data) （返回类型由 openapi-typescript 自动生成，无需手维护）接口变更三件套随批完成： - openapi.json 重导出（unified app，含 ExperienceFeedbackCreate / ExperienceFeedbackResponse / ExperienceHintItem / ExperienceHintsResponse 四个新 schema，2 个新 path 出现） - npm run gen:api 再生 frontend/src/types/api.ts（生成物，禁止手改） - npm run build 通过（vue-tsc + vite，ResultView 包 37.18 kB / 11.91 kB gzip） - docs/STATUS.md 顶部加 2026-09-24 批 3 日志条目 - docs/TECH_DEBT.md D17 追加批 3 已完成描述 + 缩减剩余工作（仅剩批 4 按需排期）设计要点： - canGiveFeedback 借 (appStore.user as any).roles 临时绕过 AppUser 类型不含 roles 的限制（前端硬规则："不要硬编码 'admin' 字符串"—— 按 role.code === 'process_engineer' 匹配） - currentAxisHint 解决 selectedScheme.axis 可能 undefined 的索引报错 - onFeedbackSubmitted 提交后立即 loadExperienceHints 触发角标刷新，实现"写入即消费"前端可见后端基线：192 passed, 13 skipped（批 3 纯前端，不动后端）。 D17 闭环端到端可用：admin / process_engineer 在 ResultView 点反馈按钮 → Dialog 提交 → 角标即时刷新 + 下次同指纹产品分析算法加成。 Co-Authored-By: Claude Code <noreply@anthropic.com>	2026-09-24 10:03:09 +08:00
cjw	505f3591ab	D17 批 2：算法接缝（OCC payload 通道 + hints 透传到分模评分）—— 闭环通让批 1 沉淀的老师傅经验 hints 真接入分模方案生成： processing_service 拉同指纹 hints 装进 OCC worker payload， planner 透传到 candidate_generator（axis 优先级加成）和 scheme_scorer（score_breakdown 新字段 + total_score 加成），写入即消费闭环通。变更内容： - src/moldinsight/core/parting_candidate_generator.py generate_candidates(..., hints=None)：_build_axis_metrics 末尾按 hints 加成（priority_score += weight × 20 上限；sample_count ≥ 2 + weight ≥ 0.5 → method 标签升级 "human_experience_primary"） - src/moldinsight/core/parting_scheme_scorer.py score_schemes(schemes, *, hints=None) keyword-only：_score_scheme 新增 human_hint_bonus 字段（weight × 12 上限；sample_count < 2 时 ×0.5 折半防信号不足过度影响）；_compute_human_hint_bonus 静态方法解析 axis （parting.axis → axis → Z）；bonus 纳入 total_score - src/moldinsight/core/multi_scheme_planner.py generate_plan(..., hints=None)：透传 hints 到 candidate_generator 与 scheme_scorer；global_summary.applied_hints 注入返回供前端 ResultView 渲染经验角标 - src/moldinsight/services/processing_service.py _step_generate_cavity 加 db_session 形参；调用 experience_feedback_service.resolve_for_process_params 拿同指纹 hints，装进 run_occ payload 顶层 experience_hints；解析失败回退空 list 不阻塞主流程（旧任务不因 receives 闭包退化） - src/moldinsight/core/occ_worker.py _op_generate_cavity：payload.get("experience_hints") or {} 透传给 planner.generate_plan(..., hints=...)；普通 dict 跨进程 pickle 安全（满足 occ_worker.py:7-8 硬规则） - tests/test_experience_feedback_algorithm.py（new）11 例： - candidate_generator 3 例（无 hints 默认 / hints 加成 / sample_count < 2 不升级） - scheme_scorer 4 例（无 hints 无 bonus / bonus 加成 / sample_count 折半 / weight=0 不加成） - multi_scheme_planner 2 例 OCC-gated（透传 / applied_hints 默认空） - processing_service 2 例 OCC-gated（payload 含 experience_hints / 解析失败回退空 list）设计取舍： - keyword-only hints：避免与位置参数混淆 - weight 仅正向上有效：max(0, (adopted-rejected)/total)，老师傅拒绝的不扣分老算法，只让采纳的加分 - signal-noise 控制：sample_count < 2 时 bonus ×0.5，但 priority_score 仍加成（候选方向仍偏向，避免完全无信号） - graceful degradation：hints 解析失败回退空 list，主流程继续 - docs/STATUS.md 顶部加 2026-09-23 批 2 日志条目 - docs/TECH_DEBT.md D17 追加批 2 已完成描述 + 缩减剩余工作（仅剩批 3 / 4）测试基线：192 passed, 13 skipped（净增 7 通过 + 4 OCC-gated skip）。 Co-Authored-By: Claude Code <noreply@anthropic.com>	2026-09-23 16:21:33 +08:00
cjw	2c9ba9d6b3	D17 批 1：Human-in-Loop 老师傅经验反馈（数据 + 权限 + 写入 API）新增 experience_feedback 表（32 表迁移，alembic head b7d1f4a92c3e），老师傅对系统推荐方案给出"采纳 / 调整 / 拒绝"反馈，按"产品指纹 + 工艺参数"为键跨任务匹配，下次同指纹产品分析自动消费。变更内容： - src/moldinsight/models/experience_feedback.py（new）ORM：Base 单点来源、跨模块裸 FK（user_id / processing_task_id / stp_file_id）、不建 ORM relationship；fingerprint JSON 列存跨任务匹配键 - src/moldinsight/models/__init__.py 导出 ExperienceFeedback - migrations/versions/b7d1f4a92c3e_add_experience_feedback.py（new）32 表迁移；fingerprint 列 PG 下加 GIN 索引（jsonb_path_query 支持） - src/shared/database/init_db.py 加 3 个权限码（view_experience_feedback / feedback_experience_hint / manage_experience_feedback）+ 新角色 process_engineer；admin 角色 permissions 同步补齐；init_permissions / init_roles 改为按 code 比对（新增保留已有 id，避免 FK 引用失效）—— 修复既有 DB 启动期漏掉新权限的幂等 bug - src/moldinsight/services/experience_feedback_service.py（new）service： compute_fingerprint 分桶（bbox_aspect / volume_bucket / face_bucket / undercut_class / material_family / is_foam）/ record_feedback（D9 边界： service.flush + 路由 commit；D17 衰减：同 stp_file_id 整体续期 90 天 TTL，无 celery beat 依赖）/ list_hints_for_task / resolve_for_process_params - src/moldinsight/api/experience_feedback_router.py（new）路由：Pydantic 模型写在路由文件内（项目硬规则）；POST /api/tasks/{task_id}/experience-feedback + GET /api/tasks/{task_id}/experience-hints；归属 TaskQueryService.ensure_task_access + User.has_permission 全仓首次调用点 - src/moldinsight/api/__init__.py ROUTE_MODULES 注册新路由 - tests/test_model_ownership.py EXPECTED_TABLES 加 experience_feedback （31→32） - tests/test_experience_feedback_fingerprint.py（new）分桶参数化覆盖 bbox / volume / face / undercut / material / is_foam 各边界值 - tests/test_experience_feedback_router.py（new）API 契约 9 例（401/403/422/200 路径 + 衰减续期 + 任务归属校验 + ORM 注册收口） - docs/STATUS.md 顶部加 2026-09-23 批 1 日志条目 - docs/TECH_DEBT.md D17 加批 1 已完成描述 + 剩余工作清单 - docs/API_CONTRACT.md §3.2 加 D17 端点表格测试基线：185 passed, 9 skipped（净增 59 测试）。 Co-Authored-By: Claude Code <noreply@anthropic.com>	2026-09-23 16:11:17 +08:00
cjw	79441a8a87	批次6：D4文档治理收口 + D13锁文件流程固化 D4 文档/规划/历史混放收口： - docs/TECH_DEBT.md §2 由'按批次回顾'精简为'按主题摘要'，与§3重复内容（批次0-4详细展开）整体迁入 docs/archive/2026-09_governance_batches.md - docs/STATUS.md 顶部 2026-09-17 之前条目迁入 docs/archive/2026-09_status_history.md，仅保留指针 - D2 历史口径补齐为 2026-09-18 批次4后续专项清偿 - D4 标已清偿 - AGENTS.md / docs/archive/README.md 同步导航 D13 锁文件流程固化（镜像引入主体已清偿，仅剩锁文件落盘）： - 新增 deploy/generate_lockfiles.{sh,bat}：在 moldinsight conda 环境（仅项目依赖）执行 pip freeze --exclude pythonocc-core，产出 deploy/requirements-{base,moldinsight}.lock.txt - deploy/Dockerfile.moldinsight 注释改为指向生成脚本 - docs/OPERATIONS.md §2.1 增加完整流程说明 - tests/test_lockfile_generation.py 加锁文件存在性+体积契约； tests/conftest.py 注册 --run-lockfile-check 选项，默认 skip（仓库单测不阻塞），CI 镜像构建 job 显式启用 fail-fast 遗留：锁文件本身尚未落盘（本机Miniforge跨项目开发栈混装，污染严重不能直接 pip freeze）；待 CI / 生产首次构建时按流程落锁。测试基线：126 passed, 9 skipped（默认4原有skip + D13新增5skip；启用 --run-lockfile-check 时严格断言2项锁文件契约） Co-Authored-By: Claude Code <noreply@anthropic.com>	2026-09-23 09:59:02 +08:00