node-resource-utils 0.0.0-stage → 1.1.8

package/resources/src/lib/feedbackAi.ts

@@ -0,0 +1,1621 @@
+import bcrypt from 'bcryptjs';
+import dayjs from 'dayjs';
+import type { SessionUser } from '@/auth';
+import { AI_MODEL, AiError, aiChatWithTools } from '@/lib/ai';
+import { audit } from '@/lib/api';
+import { prisma } from '@/lib/prisma';
+import { P, deptAllowed, hasPerm } from '@/lib/rbac';
+import { isFeedbackAdmin } from '@/lib/feedback-access';
+import { validateField } from '@/lib/validation';
+
+/**
+ * 反馈智能处理 —— 把「用户提交的一段话」变成「真正办完的事」。
+ *
+ * 为什么单独一层，而不是继续往 aiTools 里塞工具：
+ *   aiTools 是通用助手，写操作要用户点确认卡，适合"帮我建一条记录"；
+ *   而反馈页要的是一次点击直接办完 + 写回复，交互模型完全不同。
+ *   这里只用一次模型调用产出「处理方案」，真正的落库由服务端按白名单执行，
+ *   模型既不直接写库，也改不动执行结果。
+ *
+ * 四层保护：
+ *   1. 字段白名单：模型只能填已知字段，多余键丢掉
+ *   2. 证据校验：新增/修改的值必须能在反馈原文里找到；
+ *      找不到就当"没说清楚"，不执行，只回复请用户补充
+ *   3. 输入合理性校验：姓名/手机号/邮箱/身份证/日期等复用 lib/validation.ts，
+ *      格式不对同样只提示、不落库
+ *   4. 权限与数据范围：账号/员工操作复用 rbac 的权限码与部门范围判定
+ *
+ * ★ 任何异常都不往外抛：处理失败也返回一段可读的分析和提示，
+ *   反馈页因此永远不会出现 error / 404 弹窗。
+ */
+
+export type FeedbackIntent =
+  | 'reset_password'
+  | 'update_user'
+  | 'add_user'
+  | 'delete_user'
+  | 'update_employee'
+  | 'add_employee'
+  | 'delete_employee'
+  | 'none';
+
+export type FeedbackOutcome = 'done' | 'need_info' | 'unsupported' | 'failed';
+
+export interface AiStep {
+  label: string;
+  detail: string;
+  ok: boolean;
+}
+
+export interface AiChange {
+  label: string;
+  from: string;
+  to: string;
+}
+
+export interface FeedbackAiResult {
+  feedbackId: string;
+  intent: FeedbackIntent;
+  intentLabel: string;
+  confidence: number;
+  outcome: FeedbackOutcome;
+  outcomeLabel: string;
+  status: string;
+  statusLabel: string;
+  analysis: string;
+  reply: string;
+  steps: AiStep[];
+  changes: AiChange[];
+  model: string;
+  elapsedMs: number;
+  /** true = 本地模型不可用，改用规则兜底 */
+  fallback: boolean;
+}
+
+interface FeedbackPlan {
+  intent: FeedbackIntent;
+  confidence: number;
+  targetUsername: string;
+  targetName: string;
+  targetCode: string;
+  fields: Record<string, string>;
+  missing: string[];
+  analysis: string;
+  reply: string;
+}
+
+interface AuthorInfo {
+  id: string | null;
+  username: string;
+  name: string;
+  deptId: string | null;
+  deptName: string | null;
+}
+
+interface TargetUser {
+  id: string;
+  username: string;
+  name: string;
+  email: string | null;
+  phone: string | null;
+  deptId: string | null;
+  deptName: string | null;
+  status: number;
+  isSuper: number;
+}
+
+interface TargetEmployee {
+  id: string;
+  code: string;
+  name: string;
+  idCard: string | null;
+  gender: string;
+  deptId: string | null;
+  deptName: string | null;
+  position: string | null;
+  phone: string | null;
+  email: string | null;
+  hireDate: Date | null;
+  status: number;
+}
+
+interface ExecOutcome {
+  outcome: FeedbackOutcome;
+  steps: AiStep[];
+  changes: AiChange[];
+  reply: string;
+  analysis: string;
+}
+
+export const INTENT_LABEL: Record<FeedbackIntent, string> = {
+  reset_password: '重置登录密码',
+  update_user: '修改账号资料',
+  add_user: '新增系统账号',
+  delete_user: '删除系统账号',
+  update_employee: '修改员工档案',
+  add_employee: '新增员工档案',
+  delete_employee: '删除员工档案',
+  none: '非可自动办理诉求',
+};
+
+export const OUTCOME_LABEL: Record<FeedbackOutcome, string> = {
+  done: '已自动处理',
+  need_info: '信息不全，已自动回复',
+  unsupported: '暂无法自动处理，已给出分析',
+  failed: '执行未完成，已给出建议',
+};
+
+const STATUS_LABEL: Record<string, string> = {
+  pending: '待处理',
+  doing: '处理中',
+  resolved: '已解决',
+  closed: '已关闭',
+};
+
+const INTENTS: FeedbackIntent[] = [
+  'reset_password',
+  'update_user',
+  'add_user',
+  'delete_user',
+  'update_employee',
+  'add_employee',
+  'delete_employee',
+  'none',
+];
+
+const FIELD_KEYS = new Set([
+  'username',
+  'password',
+  'name',
+  'email',
+  'phone',
+  'dept',
+  'position',
+  'code',
+  'gender',
+  'hireDate',
+  'role',
+  'idCard',
+]);
+
+const FIELD_LABEL: Record<string, string> = {
+  username: '用户名',
+  password: '初始密码',
+  name: '姓名',
+  email: '邮箱',
+  phone: '手机号',
+  dept: '所属部门',
+  position: '岗位',
+  code: '工号',
+  gender: '性别',
+  hireDate: '入职日期',
+  role: '角色',
+  idCard: '身份证号',
+};
+
+const TYPE_LABEL: Record<string, string> = {
+  bug: '功能异常',
+  suggest: '体验建议',
+  data: '数据问题',
+  other: '其他',
+  account: '账号申诉',
+};
+
+/** 看起来像"没填"的占位词，一律当作空值，绝不落库 */
+const PLACEHOLDER = /^(未提供|未说明|不明确|未知|不详|暂无|待补充|待确认|null|undefined|无|—|-|\?|？)$/i;
+
+function text(v: unknown, max = 200): string {
+  return typeof v === 'string' ? v.trim().slice(0, max) : '';
+}
+
+function isBlank(v: string | null | undefined): boolean {
+  const s = String(v ?? '').trim();
+  return !s || PLACEHOLDER.test(s);
+}
+
+function normalizeText(s: string): string {
+  return s.replace(/\s+/g, '').toLowerCase();
+}
+
+/** 值的"证据"是否出现在反馈原文里（防止模型编造新的邮箱、姓名、工号） */
+function hasEvidence(key: string, value: string, source: string): boolean {
+  const v = value.trim();
+  if (!v) return false;
+  if (key === 'phone') {
+    const digits = v.replace(/\D/g, '');
+    if (digits.length >= 6) return source.replace(/\D/g, '').includes(digits);
+  }
+  return normalizeText(source).includes(normalizeText(v));
+}
+
+function clampConfidence(v: unknown): number {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return 0;
+  return Math.max(0, Math.min(1, Math.round(n * 100) / 100));
+}
+
+function normalizeIntent(v: unknown): FeedbackIntent {
+  const s = String(v ?? '').trim() as FeedbackIntent;
+  return INTENTS.includes(s) ? s : 'none';
+}
+
+function normalizeFields(raw: unknown): Record<string, string> {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(raw as Record<string, unknown>)) {
+    if (!FIELD_KEYS.has(k)) continue;
+    if (typeof v !== 'string' && typeof v !== 'number') continue;
+    // 254 与邮箱的最大长度对齐；其他字段随后还会按各自规则校验
+    const s = String(v).trim().slice(0, 254);
+    if (isBlank(s)) continue;
+    out[k] = s;
+  }
+  return out;
+}
+
+function normalizePlan(raw: Record<string, unknown>): FeedbackPlan {
+  return {
+    intent: normalizeIntent(raw.intent),
+    confidence: clampConfidence(raw.confidence),
+    targetUsername: text(raw.targetUsername, 64),
+    targetName: text(raw.targetName, 64),
+    targetCode: text(raw.targetCode, 64),
+    fields: normalizeFields(raw.fields),
+    missing: Array.isArray(raw.missing)
+      ? raw.missing.map((m) => text(m, 30)).filter(Boolean).slice(0, 6)
+      : [],
+    analysis: text(raw.analysis, 800),
+    reply: text(raw.reply, 800),
+  };
+}
+
+/* ============================ 1. 让模型出方案 ============================ */
+
+const PLAN_TOOL = {
+  type: 'function' as const,
+  function: {
+    name: 'submit_feedback_plan',
+    description: '提交这条反馈的处理方案。必须调用本工具，不要直接输出普通文字。',
+    parameters: {
+      type: 'object',
+      properties: {
+        intent: {
+          type: 'string',
+          enum: INTENTS,
+          description: '处理意图；无法自动办理时填 none',
+        },
+        confidence: { type: 'number', description: '对判断的置信度，0~1' },
+        targetUsername: { type: 'string', description: '目标账号的用户名；未明确提及他人时留空' },
+        targetName: { type: 'string', description: '目标用户或员工的姓名；未明确提及他人时留空' },
+        targetCode: { type: 'string', description: '目标员工的工号；仅员工类操作使用' },
+        fields: {
+          type: 'object',
+          description: '要写入的字段。只填反馈原文里明确出现的信息，没提到的一律不填。',
+          properties: {
+            username: { type: 'string', description: '新增账号的用户名' },
+            password: { type: 'string', description: '初始密码；未说明时留空（系统默认 123456）' },
+            name: { type: 'string', description: '姓名' },
+            email: { type: 'string', description: '邮箱' },
+            phone: { type: 'string', description: '手机号' },
+            dept: { type: 'string', description: '部门名称，必须与反馈原文一致' },
+            position: { type: 'string', description: '岗位' },
+            code: { type: 'string', description: '员工工号' },
+            gender: { type: 'string', enum: ['male', 'female'], description: '性别' },
+            hireDate: { type: 'string', description: '入职日期，如 2026-10-21' },
+            role: { type: 'string', description: '角色名称或角色码；未说明时留空' },
+            idCard: { type: 'string', description: '身份证号（15 位或 18 位）' },
+          },
+        },
+        missing: {
+          type: 'array',
+          items: { type: 'string' },
+          description: '缺少的必要信息中文名称，例如 ["工号","所属部门"]',
+        },
+        analysis: { type: 'string', description: '给管理员看的判断依据、风险和下一步建议，1~3 句' },
+        reply: { type: 'string', description: '可直接发给用户的中文回复' },
+      },
+      required: ['intent', 'confidence', 'missing', 'analysis', 'reply'],
+    },
+  },
+};
+
+const SYSTEM_PROMPT = [
+  '你是企业内部管理系统的「反馈智能处理助手」，负责阅读用户反馈并给出可执行的处理方案。',
+  '',
+  '可自动办理的意图（intent）只有：',
+  '- reset_password：忘记密码 / 密码不对 / 要重置密码；',
+  '- update_user：修改账号资料（姓名、邮箱、手机号、部门）；',
+  '- add_user：新增系统登录账号；',
+  '- delete_user：删除（停用）系统账号；',
+  '- update_employee：修改员工档案（姓名、工号、电话、邮箱、身份证号、岗位、部门）；',
+  '- add_employee：新增员工档案（新人入职、加人，可含身份证号）；',
+  '- delete_employee：删除员工档案（离职、辞退、减人）；',
+  '- none：功能异常、体验建议、数据展示问题、咨询等无法直接操作的反馈。',
+  '',
+  '判断与抽取规则：',
+  '1. 反馈已经绑定提交人账号。没有明确说处理别人时，重置密码和修改账号资料默认处理提交人本人，目标留空。',
+  '2. 只抽取反馈原文中明确出现的信息。没有出现的一律不填，绝不猜测、绝不编造。',
+  '3. 修改类必须有明确对象和明确的新值。只写“填错了/要修改”却没给出改成什么，视为信息不全。',
+  '4. 新增员工必填姓名和工号；新增账号必填用户名和姓名（密码没写时系统默认 123456，不要编造）。',
+  '5. 删除类必须能唯一确定对象（用户名、工号或姓名）；对象不明确时视为信息不全。',
+  '6. 出现“新人/入职/员工/工号/岗位/离职/辞退”等词，优先走 employee；出现“注册/账号/登录/用户名/角色/权限”等词，优先走 user。',
+  '7. 信息不全时，missing 列出中文缺项，reply 礼貌地请用户补充，并且不要声称已经执行。',
+  '8. 无法自动办理时 intent 填 none：analysis 写清原因和排查建议，reply 写一段可以直接发给用户的中文回复（包含分析和下一步建议）。',
+  '9. reply 面向普通用户，礼貌、具体、简短，不出现 JSON、代码或英文术语；analysis 面向管理员。',
+  '10. 不要声称“已处理/已完成”，真正的执行结果由系统填写。',
+].join('\n');
+
+function buildPrompt(
+  feedback: { type: string; title: string; detail: string; pagePath: string | null },
+  author: AuthorInfo | null,
+  departments: string[],
+  now: string
+): string {
+  return [
+    `当前时间：${now}`,
+    `反馈类型：${TYPE_LABEL[feedback.type] ?? feedback.type}`,
+    `标题：${feedback.title}`,
+    `详细描述：${feedback.detail}`,
+    feedback.pagePath ? `所在页面：${feedback.pagePath}` : '',
+    author
+      ? `提交人账号：${author.username}（姓名：${author.name}${author.deptName ? `，部门：${author.deptName}` : ''}）`
+      : '提交人账号：未知（账号可能已删除）',
+    '',
+    `系统内可用部门：${departments.length ? departments.join('、') : '（暂无部门数据）'}`,
+    '',
+    '请判断这条反馈能否自动办理，并调用 submit_feedback_plan 提交方案。',
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+/** 从模型文本里抠 JSON（个别引擎不遵循工具调用时的兜底） */
+function parseJsonObject(raw: string): Record<string, unknown> | null {
+  const s = raw.trim().replace(/^```(?:json)?/i, '').replace(/```$/, '');
+  const start = s.indexOf('{');
+  const end = s.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  try {
+    const parsed = JSON.parse(s.slice(start, end + 1)) as unknown;
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+async function planWithModel(
+  feedback: { type: string; title: string; detail: string; pagePath: string | null },
+  author: AuthorInfo | null,
+  departments: string[]
+): Promise<FeedbackPlan> {
+  const now = dayjs().format('YYYY-MM-DD HH:mm');
+  const turn = await aiChatWithTools({
+    system: SYSTEM_PROMPT,
+    messages: [{ role: 'user', content: buildPrompt(feedback, author, departments, now) }],
+    tools: [PLAN_TOOL],
+    toolChoice: 'required',
+    maxTokens: 700,
+    temperature: 0.1,
+  });
+
+  const call =
+    turn.toolCalls.find((c) => c.name === 'submit_feedback_plan') ?? turn.toolCalls[0];
+  let raw: Record<string, unknown> | null = call?.args ?? null;
+  if (!raw && turn.content) raw = parseJsonObject(turn.content);
+  if (!raw) throw new AiError('模型没有返回可解析的处理方案');
+  return normalizePlan(raw);
+}
+
+/**
+ * 模型不可用时的规则兜底。
+ *
+ * 只兜底"忘记密码"这种模式极其固定、误判概率低的诉求；
+ * 其余一律给分析提示，不乱执行 —— 宁可少办，也不能办错。
+ */
+function fallbackPlan(feedback: { type: string; title: string; detail: string }): FeedbackPlan {
+  const source = `${feedback.title} ${feedback.detail}`;
+  const reset =
+    /(忘记|忘了|记不住|找回|重置|改回).{0,8}密码|密码.{0,8}(忘记|忘了|重置|找回|不正确)/.test(
+      source
+    );
+  if (reset) {
+    return {
+      intent: 'reset_password',
+      confidence: 0.4,
+      targetUsername: '',
+      targetName: '',
+      targetCode: '',
+      fields: {},
+      missing: [],
+      analysis: '本地模型暂时不可用，依据「忘记密码 / 重置密码」关键词判断为密码重置诉求。',
+      reply: '已识别到密码重置诉求，将按提交人账号处理。',
+    };
+  }
+  return {
+    intent: 'none',
+    confidence: 0.2,
+    targetUsername: '',
+    targetName: '',
+    targetCode: '',
+    fields: {},
+    missing: [],
+    analysis: '本地智能模型暂时不可用，未能完成语义分析；反馈已原样保留。',
+    reply:
+      '智能处理服务当前繁忙，这条反馈已保留。请稍后重新点击「智能处理」，如情况紧急请联系管理员。',
+  };
+}
+
+/* ============================ 2. 解析目标对象 ============================ */
+
+async function loadAuthor(userId: string): Promise<AuthorInfo | null> {
+  const u = await prisma.user.findFirst({
+    where: { id: userId, deletedAt: null },
+    select: {
+      id: true,
+      username: true,
+      name: true,
+      deptId: true,
+      dept: { select: { name: true } },
+    },
+  });
+  if (!u) return null;
+  return {
+    id: u.id,
+    username: u.username,
+    name: u.name,
+    deptId: u.deptId,
+    deptName: u.dept?.name ?? null,
+  };
+}
+
+async function userById(id: string): Promise<TargetUser | null> {
+  const u = await prisma.user.findFirst({
+    where: { id, deletedAt: null },
+    select: {
+      id: true,
+      username: true,
+      name: true,
+      email: true,
+      phone: true,
+      deptId: true,
+      status: true,
+      isSuper: true,
+      dept: { select: { name: true } },
+    },
+  });
+  if (!u) return null;
+  return { ...u, deptName: u.dept?.name ?? null };
+}
+
+type ResolveResult =
+  | { ok: true; user: TargetUser }
+  | { ok: false; reply: string; missing: string[]; step: AiStep };
+
+async function resolveUserTarget(
+  plan: FeedbackPlan,
+  author: AuthorInfo | null,
+  allowSelf: boolean
+): Promise<ResolveResult> {
+  if (plan.targetUsername) {
+    const u = await prisma.user.findFirst({
+      where: { username: plan.targetUsername, deletedAt: null },
+      select: {
+        id: true,
+        username: true,
+        name: true,
+        email: true,
+        phone: true,
+        deptId: true,
+        status: true,
+        isSuper: true,
+        dept: { select: { name: true } },
+      },
+    });
+    if (!u) {
+      return {
+        ok: false,
+        missing: ['准确的用户名'],
+        step: {
+          label: '定位账号',
+          detail: `没有找到用户名「${plan.targetUsername}」`,
+          ok: false,
+        },
+        reply: `没有找到用户名为「${plan.targetUsername}」的账号，暂未执行任何变更。请核对后重新处理。`,
+      };
+    }
+    return { ok: true, user: { ...u, deptName: u.dept?.name ?? null } };
+  }
+
+  if (plan.targetName) {
+    const rows = await prisma.user.findMany({
+      where: { name: plan.targetName, deletedAt: null },
+      select: {
+        id: true,
+        username: true,
+        name: true,
+        email: true,
+        phone: true,
+        deptId: true,
+        status: true,
+        isSuper: true,
+        dept: { select: { name: true } },
+      },
+      take: 6,
+    });
+    if (rows.length === 1) {
+      const u = rows[0];
+      return { ok: true, user: { ...u, deptName: u.dept?.name ?? null } };
+    }
+    if (rows.length > 1) {
+      const names = rows.map((u) => `${u.username}（${u.name}）`).join('、');
+      return {
+        ok: false,
+        missing: ['准确的用户名'],
+        step: {
+          label: '定位账号',
+          detail: `姓名「${plan.targetName}」匹配到 ${rows.length} 个账号`,
+          ok: false,
+        },
+        reply: `系统中存在多个名为「${plan.targetName}」的账号：${names}。为避免改错人，暂未执行，请提供准确的用户名。`,
+      };
+    }
+    return {
+      ok: false,
+      missing: ['准确的用户名'],
+      step: {
+        label: '定位账号',
+        detail: `没有找到姓名为「${plan.targetName}」的账号`,
+        ok: false,
+      },
+      reply: `没有找到姓名为「${plan.targetName}」的账号，暂未执行任何变更。请核对姓名或补充用户名。`,
+    };
+  }
+
+  if (!allowSelf) {
+    return {
+      ok: false,
+      missing: ['要操作的账号（用户名或姓名）'],
+      step: { label: '定位账号', detail: '反馈中没有说明要处理哪个账号', ok: false },
+      reply: '反馈中没有说明要处理哪个账号，暂未执行任何变更。请补充用户名或姓名。',
+    };
+  }
+
+  if (!author?.id) {
+    return {
+      ok: false,
+      missing: ['提交人账号'],
+      step: { label: '定位账号', detail: '提交人账号已不存在', ok: false },
+      reply: '提交人账号已不存在，无法按本人处理。请联系管理员人工核实。',
+    };
+  }
+
+  const me = await userById(author.id);
+  if (!me) {
+    return {
+      ok: false,
+      missing: ['提交人账号'],
+      step: { label: '定位账号', detail: '提交人账号已不存在', ok: false },
+      reply: '提交人账号已不存在，无法按本人处理。请联系管理员人工核实。',
+    };
+  }
+  return { ok: true, user: me };
+}
+
+async function resolveEmployeeTarget(
+  plan: FeedbackPlan
+): Promise<
+  | { ok: true; employee: TargetEmployee }
+  | { ok: false; reply: string; missing: string[]; step: AiStep }
+> {
+  const select = {
+    id: true,
+    code: true,
+    name: true,
+    idCard: true,
+    gender: true,
+    deptId: true,
+    position: true,
+    phone: true,
+    email: true,
+    hireDate: true,
+    status: true,
+    dept: { select: { name: true } },
+  } as const;
+
+  if (plan.targetCode) {
+    const e = await prisma.employee.findFirst({
+      where: { code: plan.targetCode, deletedAt: null },
+      select,
+    });
+    if (!e) {
+      return {
+        ok: false,
+        missing: ['准确的工号'],
+        step: { label: '定位员工', detail: `没有找到工号「${plan.targetCode}」`, ok: false },
+        reply: `没有找到工号为「${plan.targetCode}」的员工，暂未执行任何变更。请核对工号。`,
+      };
+    }
+    return { ok: true, employee: { ...e, deptName: e.dept?.name ?? null } };
+  }
+
+  if (plan.targetName) {
+    const rows = await prisma.employee.findMany({
+      where: { name: plan.targetName, deletedAt: null },
+      select,
+      take: 6,
+    });
+    if (rows.length === 1) {
+      const e = rows[0];
+      return { ok: true, employee: { ...e, deptName: e.dept?.name ?? null } };
+    }
+    if (rows.length > 1) {
+      const names = rows.map((e) => `${e.code}（${e.name}）`).join('、');
+      return {
+        ok: false,
+        missing: ['准确的工号'],
+        step: {
+          label: '定位员工',
+          detail: `姓名「${plan.targetName}」匹配到 ${rows.length} 条员工档案`,
+          ok: false,
+        },
+        reply: `系统中存在多条姓名为「${plan.targetName}」的员工档案：${names}。为避免误删/误改，暂未执行，请提供准确的工号。`,
+      };
+    }
+    return {
+      ok: false,
+      missing: ['准确的工号'],
+      step: {
+        label: '定位员工',
+        detail: `没有找到姓名为「${plan.targetName}」的员工`,
+        ok: false,
+      },
+      reply: `没有找到姓名为「${plan.targetName}」的员工档案，暂未执行任何变更。请核对姓名或补充工号。`,
+    };
+  }
+
+  return {
+    ok: false,
+    missing: ['要操作的员工（姓名或工号）'],
+    step: { label: '定位员工', detail: '反馈中没有说明要处理哪位员工', ok: false },
+    reply: '反馈中没有说明要处理哪位员工，暂未执行任何变更。请补充姓名或工号。',
+  };
+}
+
+/* ============================ 3. 校验与执行 ============================ */
+
+function needInfo(reply: string, _missing: string[], steps: AiStep[], analysis = ''): ExecOutcome {
+  // 目标定位失败的文案本身已经说明"暂未执行"，避免重复前缀
+  const prefix = /暂未|没有执行|未执行/.test(reply) ? '' : '暂未执行任何变更：';
+  return {
+    outcome: 'need_info',
+    steps,
+    changes: [],
+    reply: `【AI 智能处理】${prefix}${reply}`,
+    analysis: analysis || '信息不足，按“宁可不办、不可办错”的原则保持数据不变。',
+  };
+}
+
+function unsupported(reply: string, steps: AiStep[], analysis: string): ExecOutcome {
+  return {
+    outcome: 'unsupported',
+    steps,
+    changes: [],
+    reply: `【AI 智能处理】${reply}${analysis ? `\n\n处理分析：${analysis}` : ''}`,
+    analysis,
+  };
+}
+
+function failed(reason: string, steps: AiStep[], analysis = ''): ExecOutcome {
+  return {
+    outcome: 'failed',
+    steps,
+    changes: [],
+    reply: `【AI 智能处理】已分析这条反馈，但自动执行没有完成：${reason}。建议核对信息后重新点击「智能处理」，或联系管理员人工处理。`,
+    analysis: analysis || '执行阶段被业务规则拦截，数据没有被修改。',
+  };
+}
+
+/**
+ * AI 抽取出来的字段统一走输入校验底座。
+ * 不合法时返回 needInfo（不是抛异常）：既守住数据质量，也保证反馈页永远有可读提示。
+ */
+function checkField(
+  type: string,
+  value: string,
+  label: string,
+  steps: AiStep[],
+  required = false
+): { ok: true; value: string } | { ok: false; outcome: ExecOutcome } {
+  const result = validateField(type, value, { label, required });
+  if (result.ok) return { ok: true, value: result.value };
+  return {
+    ok: false,
+    outcome: needInfo(result.message, [`正确的${label}`], [
+      ...steps,
+      { label: '输入合理性校验', detail: result.message, ok: false },
+    ]),
+  };
+}
+
+function labelOf(key: string): string {
+  return FIELD_LABEL[key] ?? key;
+}
+
+function valueOr(v: string | null | undefined): string {
+  return v && String(v).trim() ? String(v) : '（空）';
+}
+
+/** 修改类的证据校验：反馈里没出现的值，不能当成用户的要求 */
+function verifyFields(
+  fields: Record<string, string>,
+  keys: string[],
+  source: string,
+  missing: string[],
+  optionalKeys: string[] = []
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const key of keys) {
+    const v = fields[key];
+    if (!v) continue;
+    if (hasEvidence(key, v, source)) out[key] = v;
+    else if (!optionalKeys.includes(key) && !missing.includes(labelOf(key))) {
+      missing.push(labelOf(key));
+    }
+  }
+  return out;
+}
+
+async function findDeptId(name: string): Promise<string | null> {
+  if (!name) return null;
+  const d = await prisma.department.findFirst({
+    where: { name: name.trim(), status: 1 },
+    select: { id: true },
+  });
+  return d?.id ?? null;
+}
+
+function parseDate(v: string): Date | null {
+  if (!v) return null;
+  const d = dayjs(v);
+  return d.isValid() ? d.toDate() : null;
+}
+
+function deptNotAllowedOutcome(): ExecOutcome {
+  return unsupported(
+    '你的数据范围不包含目标部门，暂未执行任何变更。',
+    [{ label: '数据范围校验', detail: '目标不在当前账号可管理的部门内', ok: false }],
+    '数据范围校验未通过：只能处理自己有权管理的部门。'
+  );
+}
+
+async function executePlan(
+  plan: FeedbackPlan,
+  feedback: { id: string; type: string; title: string; detail: string; userId: string },
+  author: AuthorInfo | null,
+  operator: SessionUser
+): Promise<ExecOutcome> {
+  const source = `${feedback.title}\n${feedback.detail}`;
+  const steps: AiStep[] = [];
+  const changes: AiChange[] = [];
+  const departments = await prisma.department.findMany({
+    where: { status: 1 },
+    select: { name: true },
+    take: 200,
+  });
+
+  switch (plan.intent) {
+    /* ---------------------------- 重置密码 ---------------------------- */
+    case 'reset_password': {
+      const target = await resolveUserTarget(plan, author, true);
+      if (!target.ok) return needInfo(target.reply, target.missing, [target.step]);
+      const u = target.user;
+      steps.push({ label: '定位账号', detail: `${u.username}（${u.name}）`, ok: true });
+
+      if (operator.id !== u.id && !hasPerm(operator, P.userReset)) {
+        return unsupported(
+          `当前账号没有重置「${u.username}」密码的权限，暂未执行。请联系超级管理员或系统管理员处理。`,
+          steps,
+          '密码重置属于账号安全操作，需要 system:user:reset 权限。'
+        );
+      }
+      if (operator.id !== u.id && !deptAllowed(operator, u.deptId)) {
+        return deptNotAllowedOutcome();
+      }
+      if (u.status !== 1) {
+        return unsupported(
+          `账号「${u.username}」当前是停用状态，密码已重置也无法登录。请先由管理员启用账号。`,
+          [...steps, { label: '账号状态校验', detail: '账号已停用', ok: false }],
+          '账号状态为停用，密码重置不会恢复登录能力。'
+        );
+      }
+
+      const password = '123456';
+      await prisma.user.update({
+        where: { id: u.id },
+        data: { password: await bcrypt.hash(password, 10), mustChangePassword: 1 },
+      });
+      steps.push({ label: '重置密码', detail: '新密码 123456，下次登录需修改', ok: true });
+
+      const self = operator.id === u.id;
+      const reply = self
+        ? '已重置你的登录密码，新密码为 123456。为保障账号安全，请在下次登录后按提示立即修改密码。'
+        : `已按反馈重置账号「${u.username}」的登录密码，新密码为 123456。该用户下次登录时需先修改密码。`;
+      return {
+        outcome: 'done',
+        steps,
+        changes: [{ label: '登录密码', from: '（原密码）', to: '123456' }],
+        reply,
+        analysis: plan.analysis || '密码重置已完成，并已标记下次登录强制改密。',
+      };
+    }
+
+    /* ---------------------------- 修改账号资料 ---------------------------- */
+    case 'update_user': {
+      const target = await resolveUserTarget(plan, author, true);
+      if (!target.ok) return needInfo(target.reply, target.missing, [target.step]);
+      const u = target.user;
+      steps.push({ label: '定位账号', detail: `${u.username}（${u.name}）`, ok: true });
+
+      const self = operator.id === u.id;
+      if (!self && !hasPerm(operator, P.userEdit)) {
+        return unsupported(
+          `当前账号没有修改「${u.username}」资料的权限，暂未执行。请联系系统管理员处理。`,
+          steps,
+          '修改他人账号资料需要 system:user:edit 权限。'
+        );
+      }
+      if (!self && !deptAllowed(operator, u.deptId)) return deptNotAllowedOutcome();
+
+      // 部门变更只允许有编辑权限的人做，普通用户不能自己调部门
+      const allowedKeys = self && !hasPerm(operator, P.userEdit)
+        ? ['name', 'email', 'phone']
+        : ['name', 'email', 'phone', 'dept'];
+      const missing: string[] = [];
+      const fields = verifyFields(plan.fields, allowedKeys, source, missing);
+      // 修改类只要有一项没说明白，就整体不执行，避免"改一半"
+      if (missing.length) {
+        return needInfo(
+          `反馈里没有明确写出这些字段的新值：${[...new Set(missing)].join('、')}。为免改错，暂未执行任何变更，请补充后重新处理。`,
+          missing,
+          steps
+        );
+      }
+
+      if (plan.fields.dept && !allowedKeys.includes('dept')) {
+        return unsupported(
+          '所属部门不能由本人修改，请由管理员在用户管理中调整。',
+          steps,
+          '部门变更涉及数据范围与权限，属于管理操作。'
+        );
+      }
+      if (!Object.keys(fields).length) {
+        return needInfo(
+          '请说明要修改的具体字段和正确的新值（例如：姓名改为“张三”、邮箱改为“xx@example.com”）。',
+          missing.length ? missing : ['要修改的内容和正确的新值'],
+          steps
+        );
+      }
+
+      const data: Record<string, unknown> = {};
+      const deptName = fields.dept ?? '';
+
+      if (fields.name) {
+        const checked = checkField('name', fields.name, '姓名', steps, true);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value !== u.name) {
+          data.name = checked.value;
+          changes.push({ label: '姓名', from: valueOr(u.name), to: checked.value });
+        }
+      }
+      if (fields.email) {
+        const checked = checkField('email', fields.email, '邮箱', steps, true);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value.toLowerCase() !== (u.email ?? '').toLowerCase()) {
+          data.email = checked.value;
+          changes.push({ label: '邮箱', from: valueOr(u.email), to: checked.value });
+        }
+      }
+      if (fields.phone) {
+        const checked = checkField('phone', fields.phone, '手机号', steps, true);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value !== (u.phone ?? '')) {
+          data.phone = checked.value;
+          changes.push({ label: '手机号', from: valueOr(u.phone), to: checked.value });
+        }
+      }
+      if (deptName) {
+        const deptId = await findDeptId(deptName);
+        if (!deptId) {
+          return needInfo(
+            `系统中没有找到部门「${deptName}」。可选部门：${departments.map((d) => d.name).join('、')}。`,
+            ['正确的所属部门'],
+            steps
+          );
+        }
+        if (deptId !== u.deptId) {
+          data.deptId = deptId;
+          changes.push({ label: '所属部门', from: valueOr(u.deptName), to: deptName });
+        }
+      }
+
+      if (!Object.keys(data).length) {
+        return {
+          outcome: 'done',
+          steps: [...steps, { label: '核对资料', detail: '反馈内容与现有资料一致，无需修改', ok: true }],
+          changes: [],
+          reply: '已核对你的账号资料，反馈中的内容与现有资料一致，无需修改。',
+          analysis: '字段值与现状一致，未产生数据库写入。',
+        };
+      }
+
+      await prisma.user.update({ where: { id: u.id }, data });
+      steps.push({
+        label: '更新账号资料',
+        detail: changes.map((c) => `${c.label} ${c.from} → ${c.to}`).join('；'),
+        ok: true,
+      });
+
+      return {
+        outcome: 'done',
+        steps,
+        changes,
+        reply: `已按反馈修改账号「${u.username}」的资料：${changes
+          .map((c) => `${c.label}由「${c.from}」改为「${c.to}」`)
+          .join('；')}。`,
+        analysis: plan.analysis || '账号资料已按反馈更新完成。',
+      };
+    }
+
+    /* ---------------------------- 新增账号 ---------------------------- */
+    case 'add_user': {
+      if (!hasPerm(operator, P.userAdd)) {
+        return unsupported(
+          '当前账号没有新增系统用户的权限，暂未创建任何账号。请由系统管理员在用户管理中新增。',
+          [{ label: '权限校验', detail: '缺少 system:user:add 权限', ok: false }],
+          '新增登录账号涉及账号与权限分配，只能由有用户管理权限的人执行。'
+        );
+      }
+
+      const missing: string[] = [];
+      const fields = verifyFields(
+        plan.fields,
+        ['username', 'password', 'name', 'email', 'phone', 'dept', 'role'],
+        source,
+        missing,
+        ['password', 'email', 'phone', 'dept', 'role'] // 选填：原文没写就忽略，不阻塞创建
+      );
+
+      let username = fields.username ?? '';
+      let name = fields.name ?? '';
+      if (!username && !missing.includes('用户名')) missing.unshift('用户名');
+      if (!name && !missing.includes('姓名')) missing.unshift('姓名');
+      if (missing.length) {
+        return needInfo(
+          `新增账号还缺少：${[...new Set(missing)].join('、')}。请补充后重新点击「智能处理」。`,
+          [...new Set(missing)],
+          steps
+        );
+      }
+
+      const usernameCheck = checkField('username', username, '用户名', steps, true);
+      if (!usernameCheck.ok) return usernameCheck.outcome;
+      username = usernameCheck.value;
+
+      const nameCheck = checkField('name', name, '姓名', steps, true);
+      if (!nameCheck.ok) return nameCheck.outcome;
+      name = nameCheck.value;
+
+      let password = '123456';
+      if (fields.password) {
+        const passwordCheck = checkField('password', fields.password, '初始密码', steps, true);
+        if (!passwordCheck.ok) return passwordCheck.outcome;
+        password = passwordCheck.value;
+      }
+
+      const existed = await prisma.user.findUnique({ where: { username } });
+      if (existed) {
+        return failed(
+          `用户名「${username}」已被占用（含已删除账号）`,
+          [...steps, { label: '用户名查重', detail: `${username} 已存在`, ok: false }],
+          '用户名必须全局唯一，请更换一个用户名后重试。'
+        );
+      }
+
+      const data: Record<string, unknown> = {
+        username,
+        name,
+        password: await bcrypt.hash(password, 10),
+        mustChangePassword: 1,
+      };
+      if (fields.email) {
+        const checked = checkField('email', fields.email, '邮箱', steps, true);
+        if (!checked.ok) return checked.outcome;
+        data.email = checked.value;
+      }
+      if (fields.phone) {
+        const checked = checkField('phone', fields.phone, '手机号', steps, true);
+        if (!checked.ok) return checked.outcome;
+        data.phone = checked.value;
+      }
+      if (fields.dept) {
+        const deptId = await findDeptId(fields.dept);
+        if (!deptId) {
+          return needInfo(
+            `系统中没有找到部门「${fields.dept}」。可选部门：${departments
+              .map((d) => d.name)
+              .join('、')}。`,
+            ['正确的所属部门'],
+            steps
+          );
+        }
+        if (!deptAllowed(operator, deptId)) return deptNotAllowedOutcome();
+        data.deptId = deptId;
+      }
+
+      // 角色：默认普通员工；指定管理员角色时只有超管能这么做
+      let roleId: string | null = null;
+      let roleName = '普通员工';
+      if (fields.role) {
+        const role = await prisma.role.findFirst({
+          where: {
+            status: 1,
+            OR: [{ code: fields.role }, { name: fields.role }],
+          },
+          select: { id: true, code: true, name: true },
+        });
+        if (role) {
+          if (role.code === 'admin' && !operator.isSuper) {
+            return unsupported(
+              '当前账号不能通过智能处理创建管理员账号，暂未创建。请联系超级管理员。',
+              [...steps, { label: '角色校验', detail: '禁止分配管理员角色', ok: false }],
+              '管理员账号创建属于高权限操作，只允许超级管理员执行。'
+            );
+          }
+          roleId = role.id;
+          roleName = role.name;
+        }
+      }
+      if (!roleId) {
+        const staff = await prisma.role.findFirst({
+          where: { code: 'staff', status: 1 },
+          select: { id: true, name: true },
+        });
+        if (staff) {
+          roleId = staff.id;
+          roleName = staff.name;
+        }
+      }
+      if (roleId) data.roles = { create: [{ roleId }] };
+
+      const created = await prisma.user.create({
+        data: data as Parameters<typeof prisma.user.create>[0]['data'],
+      });
+      const pwd = password;
+      steps.push({ label: '创建账号', detail: `${username}（${name}）`, ok: true });
+      if (roleId) steps.push({ label: '分配角色', detail: roleName, ok: true });
+
+      return {
+        outcome: 'done',
+        steps,
+        changes: [
+          { label: '用户名', from: '（新账号）', to: username },
+          { label: '姓名', from: '（新账号）', to: name },
+          ...(fields.dept ? [{ label: '所属部门', from: '（新账号）', to: fields.dept }] : []),
+          { label: '角色', from: '（新账号）', to: roleName },
+        ],
+        reply: `已新增系统账号「${username}」（姓名：${name}${
+          fields.dept ? `，部门：${fields.dept}` : ''
+        }），初始密码 ${pwd}，角色为「${roleName}」。请提醒本人首次登录后修改密码。`,
+        analysis: plan.analysis || `账号已创建（id=${created.id}），初始密码已标记为首次登录需修改。`,
+      };
+    }
+
+    /* ---------------------------- 删除账号 ---------------------------- */
+    case 'delete_user': {
+      if (!hasPerm(operator, P.userDel)) {
+        return unsupported(
+          '当前账号没有删除系统用户的权限，暂未执行。请由系统管理员处理。',
+          [{ label: '权限校验', detail: '缺少 system:user:del 权限', ok: false }],
+          '删除账号属于高影响操作，需要 system:user:del 权限。'
+        );
+      }
+      const target = await resolveUserTarget(plan, author, false);
+      if (!target.ok) return needInfo(target.reply, target.missing, [target.step]);
+      const u = target.user;
+      steps.push({ label: '定位账号', detail: `${u.username}（${u.name}）`, ok: true });
+
+      if (u.id === operator.id) {
+        return unsupported(
+          '不能删除当前登录的账号，暂未执行。',
+          [...steps, { label: '安全校验', detail: '目标是当前登录账号', ok: false }],
+          '删除当前登录账号会让操作人立刻失去访问能力。'
+        );
+      }
+      if (u.isSuper === 1) {
+        return unsupported(
+          '超级管理员账号不允许删除，暂未执行。',
+          [...steps, { label: '安全校验', detail: '目标是超级管理员', ok: false }],
+          '超级管理员账号是系统最后的管理入口，必须保留。'
+        );
+      }
+      if (!deptAllowed(operator, u.deptId)) return deptNotAllowedOutcome();
+
+      await prisma.user.update({ where: { id: u.id }, data: { deletedAt: new Date() } });
+      steps.push({ label: '删除账号', detail: '已软删除，可在审计日志追溯', ok: true });
+
+      return {
+        outcome: 'done',
+        steps,
+        changes: [{ label: '账号状态', from: '在用', to: '已删除（软删除）' }],
+        reply: `已删除系统账号「${u.username}」（姓名：${u.name}）。该账号已停用并从用户列表中移除。`,
+        analysis: plan.analysis || '账号已软删除，历史数据与审计记录保留。',
+      };
+    }
+
+    /* ---------------------------- 新增员工 ---------------------------- */
+    case 'add_employee': {
+      if (!hasPerm(operator, P.empAdd)) {
+        return unsupported(
+          '当前账号没有新增员工的权限，暂未创建任何档案。请由有员工管理权限的人处理。',
+          [{ label: '权限校验', detail: '缺少 demo:employee:add 权限', ok: false }],
+          '新增员工档案需要员工管理的新增权限。'
+        );
+      }
+
+      const missing: string[] = [];
+      const fields = verifyFields(
+        plan.fields,
+        ['code', 'name', 'idCard', 'dept', 'position', 'phone', 'email', 'hireDate'],
+        source,
+        missing,
+        ['idCard', 'dept', 'position', 'phone', 'email', 'hireDate'] // 选填：原文没写就忽略
+      );
+      let code = fields.code ?? '';
+      let name = fields.name ?? '';
+      if (!code && !missing.includes('工号')) missing.unshift('工号');
+      if (!name && !missing.includes('姓名')) missing.unshift('姓名');
+      if (missing.length) {
+        return needInfo(
+          `新增员工还缺少：${[...new Set(missing)].join('、')}。信息不完整，暂未创建任何档案。请补充后重新点击「智能处理」。`,
+          [...new Set(missing)],
+          steps
+        );
+      }
+
+      const codeCheck = checkField('code', code, '工号', steps, true);
+      if (!codeCheck.ok) return codeCheck.outcome;
+      code = codeCheck.value;
+
+      const nameCheck = checkField('name', name, '姓名', steps, true);
+      if (!nameCheck.ok) return nameCheck.outcome;
+      name = nameCheck.value;
+
+      const existed = await prisma.employee.findUnique({ where: { code } });
+      if (existed) {
+        return failed(
+          `工号「${code}」已存在`,
+          [...steps, { label: '工号查重', detail: `${code} 已被使用`, ok: false }],
+          '工号必须唯一，请核对后再新增。'
+        );
+      }
+
+      const data: Record<string, unknown> = {
+        code,
+        name,
+        gender: fields.gender === 'female' ? 'female' : 'male',
+      };
+      if (fields.position) data.position = fields.position;
+      if (fields.idCard) {
+        const checked = checkField('idCard', fields.idCard, '身份证号', steps);
+        if (!checked.ok) return checked.outcome;
+        data.idCard = checked.value;
+      }
+      if (fields.phone) {
+        const checked = checkField('phone', fields.phone, '手机号', steps);
+        if (!checked.ok) return checked.outcome;
+        data.phone = checked.value;
+      }
+      if (fields.email) {
+        const checked = checkField('email', fields.email, '邮箱', steps);
+        if (!checked.ok) return checked.outcome;
+        data.email = checked.value;
+      }
+      if (fields.hireDate) {
+        const checked = checkField('date', fields.hireDate, '入职日期', steps);
+        if (!checked.ok) return checked.outcome;
+        const d = parseDate(checked.value);
+        if (!d) return needInfo('入职日期格式无法识别。', ['正确的入职日期'], steps);
+        data.hireDate = d;
+      }
+      if (fields.dept) {
+        const deptId = await findDeptId(fields.dept);
+        if (!deptId) {
+          return needInfo(
+            `系统中没有找到部门「${fields.dept}」。可选部门：${departments
+              .map((d) => d.name)
+              .join('、')}。`,
+            ['正确的所属部门'],
+            steps
+          );
+        }
+        if (!deptAllowed(operator, deptId)) return deptNotAllowedOutcome();
+        data.deptId = deptId;
+      }
+
+      const created = await prisma.employee.create({
+        data: data as Parameters<typeof prisma.employee.create>[0]['data'],
+      });
+      steps.push({ label: '创建员工档案', detail: `${name}（工号 ${code}）`, ok: true });
+
+      return {
+        outcome: 'done',
+        steps,
+        changes: [
+          { label: '工号', from: '（新档案）', to: code },
+          { label: '姓名', from: '（新档案）', to: name },
+          ...(fields.dept ? [{ label: '所属部门', from: '（新档案）', to: fields.dept }] : []),
+          ...(fields.position ? [{ label: '岗位', from: '（新档案）', to: fields.position }] : []),
+        ],
+        reply: `已新增员工「${name}」（工号 ${code}${
+          fields.dept ? `，部门：${fields.dept}` : ''
+        }${fields.position ? `，岗位：${fields.position}` : ''}）。`,
+        analysis: plan.analysis || `员工档案已创建（id=${created.id}）。`,
+      };
+    }
+
+    /* ---------------------------- 修改员工档案 ---------------------------- */
+    case 'update_employee': {
+      if (!hasPerm(operator, P.empEdit)) {
+        return unsupported(
+          '当前账号没有修改员工档案的权限，暂未执行。请由有员工管理权限的人处理。',
+          [{ label: '权限校验', detail: '缺少 demo:employee:edit 权限', ok: false }],
+          '修改员工档案需要员工管理的编辑权限。'
+        );
+      }
+      const target = await resolveEmployeeTarget(plan);
+      if (!target.ok) return needInfo(target.reply, target.missing, [target.step]);
+      const e = target.employee;
+      steps.push({ label: '定位员工', detail: `${e.name}（工号 ${e.code}）`, ok: true });
+      if (!deptAllowed(operator, e.deptId)) return deptNotAllowedOutcome();
+
+      const missing: string[] = [];
+      const fields = verifyFields(
+        plan.fields,
+        ['name', 'code', 'idCard', 'dept', 'position', 'phone', 'email', 'hireDate'],
+        source,
+        missing
+      );
+      // 修改类只要有一项没说明白，就整体不执行
+      if (missing.length) {
+        return needInfo(
+          `反馈里没有明确写出这些字段的新值：${[...new Set(missing)].join('、')}。为免改错，暂未执行任何变更，请补充后重新处理。`,
+          missing,
+          steps
+        );
+      }
+      if (!Object.keys(fields).length) {
+        return needInfo(
+          '请说明要修改的具体字段和正确的新值（例如：手机号改为 138xxxx、岗位改为“技术主管”）。',
+          missing.length ? missing : ['要修改的内容和正确的新值'],
+          steps
+        );
+      }
+
+      const data: Record<string, unknown> = {};
+      if (fields.name) {
+        const checked = checkField('name', fields.name, '姓名', steps, true);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value !== e.name) {
+          data.name = checked.value;
+          changes.push({ label: '姓名', from: valueOr(e.name), to: checked.value });
+        }
+      }
+      if (fields.code) {
+        const checked = checkField('code', fields.code, '工号', steps, true);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value !== e.code) {
+          const dup = await prisma.employee.findUnique({ where: { code: checked.value } });
+          if (dup) {
+            return failed(
+              `工号「${checked.value}」已被占用`,
+              [...steps, { label: '工号查重', detail: `${checked.value} 已存在`, ok: false }],
+              '工号必须唯一，请更换后再修改。'
+            );
+          }
+          data.code = checked.value;
+          changes.push({ label: '工号', from: valueOr(e.code), to: checked.value });
+        }
+      }
+      if (fields.idCard) {
+        const checked = checkField('idCard', fields.idCard, '身份证号', steps);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value !== (e.idCard ?? '')) {
+          data.idCard = checked.value;
+          changes.push({ label: '身份证号', from: valueOr(e.idCard), to: checked.value });
+        }
+      }
+      if (fields.phone) {
+        const checked = checkField('phone', fields.phone, '手机号', steps);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value !== (e.phone ?? '')) {
+          data.phone = checked.value;
+          changes.push({ label: '手机号', from: valueOr(e.phone), to: checked.value });
+        }
+      }
+      if (fields.email) {
+        const checked = checkField('email', fields.email, '邮箱', steps);
+        if (!checked.ok) return checked.outcome;
+        if (checked.value.toLowerCase() !== (e.email ?? '').toLowerCase()) {
+          data.email = checked.value;
+          changes.push({ label: '邮箱', from: valueOr(e.email), to: checked.value });
+        }
+      }
+      if (fields.position && fields.position !== (e.position ?? '')) {
+        data.position = fields.position;
+        changes.push({ label: '岗位', from: valueOr(e.position), to: fields.position });
+      }
+      if (fields.hireDate) {
+        const checked = checkField('date', fields.hireDate, '入职日期', steps);
+        if (!checked.ok) return checked.outcome;
+        const d = parseDate(checked.value);
+        if (!d) return needInfo('入职日期格式无法识别。', ['正确的入职日期'], steps);
+        data.hireDate = d;
+        changes.push({
+          label: '入职日期',
+          from: e.hireDate ? dayjs(e.hireDate).format('YYYY-MM-DD') : '（空）',
+          to: dayjs(d).format('YYYY-MM-DD'),
+        });
+      }
+      if (fields.dept) {
+        const deptId = await findDeptId(fields.dept);
+        if (!deptId) {
+          return needInfo(
+            `系统中没有找到部门「${fields.dept}」。可选部门：${departments
+              .map((d) => d.name)
+              .join('、')}。`,
+            ['正确的所属部门'],
+            steps
+          );
+        }
+        if (!deptAllowed(operator, deptId)) return deptNotAllowedOutcome();
+        if (deptId !== e.deptId) {
+          data.deptId = deptId;
+          changes.push({ label: '所属部门', from: valueOr(e.deptName), to: fields.dept });
+        }
+      }
+
+      if (!Object.keys(data).length) {
+        return {
+          outcome: 'done',
+          steps: [...steps, { label: '核对档案', detail: '反馈内容与现有档案一致，无需修改', ok: true }],
+          changes: [],
+          reply: '已核对员工档案，反馈中的内容与现有档案一致，无需修改。',
+          analysis: '字段值与现状一致，未产生数据库写入。',
+        };
+      }
+
+      await prisma.employee.update({ where: { id: e.id }, data });
+      steps.push({
+        label: '更新员工档案',
+        detail: changes.map((c) => `${c.label} ${c.from} → ${c.to}`).join('；'),
+        ok: true,
+      });
+      return {
+        outcome: 'done',
+        steps,
+        changes,
+        reply: `已按反馈修改员工「${e.name}」（工号 ${e.code}）的档案：${changes
+          .map((c) => `${c.label}由「${c.from}」改为「${c.to}」`)
+          .join('；')}。`,
+        analysis: plan.analysis || '员工档案已按反馈更新完成。',
+      };
+    }
+
+    /* ---------------------------- 删除员工档案 ---------------------------- */
+    case 'delete_employee': {
+      if (!hasPerm(operator, P.empDel)) {
+        return unsupported(
+          '当前账号没有删除员工的权限，暂未执行。请由有员工管理权限的人处理。',
+          [{ label: '权限校验', detail: '缺少 demo:employee:del 权限', ok: false }],
+          '删除员工档案需要员工管理的删除权限。'
+        );
+      }
+      const target = await resolveEmployeeTarget(plan);
+      if (!target.ok) return needInfo(target.reply, target.missing, [target.step]);
+      const e = target.employee;
+      steps.push({ label: '定位员工', detail: `${e.name}（工号 ${e.code}）`, ok: true });
+      if (!deptAllowed(operator, e.deptId)) return deptNotAllowedOutcome();
+
+      await prisma.employee.update({
+        where: { id: e.id },
+        data: { deletedAt: new Date() },
+      });
+      steps.push({ label: '删除员工档案', detail: '已软删除，可在审计日志追溯', ok: true });
+
+      return {
+        outcome: 'done',
+        steps,
+        changes: [{ label: '档案状态', from: '在职', to: '已删除（软删除）' }],
+        reply: `已删除员工「${e.name}」（工号 ${e.code}）的员工档案。`,
+        analysis: plan.analysis || '员工档案已软删除，历史数据与审计记录保留。',
+      };
+    }
+
+    /* ---------------------------- 无法自动办理 ---------------------------- */
+    default: {
+      const analysis =
+        plan.analysis ||
+        '这条反馈属于需要人工判断的问题，AI 无法直接修改系统数据或代码。';
+      const reply =
+        plan.reply ||
+        `已收到反馈。经智能分析，这条内容需要开发或管理员进一步核实，已保留原始记录并标记为需要跟进。`;
+      return unsupported(reply, steps, analysis);
+    }
+  }
+}
+
+/* ============================ 4. 对外入口 ============================ */
+
+const NOWHERE = '这条反馈可能已被删除。';
+
+function emptyResult(
+  feedbackId: string,
+  outcome: FeedbackOutcome,
+  reply: string,
+  analysis: string,
+  elapsedMs: number,
+  fallback = false
+): FeedbackAiResult {
+  return {
+    feedbackId,
+    intent: 'none',
+    intentLabel: INTENT_LABEL.none,
+    confidence: 0,
+    outcome,
+    outcomeLabel: OUTCOME_LABEL[outcome],
+    status: 'pending',
+    statusLabel: STATUS_LABEL.pending,
+    analysis,
+    reply,
+    steps: [],
+    changes: [],
+    model: AI_MODEL,
+    elapsedMs,
+    fallback,
+  };
+}
+
+/**
+ * 处理一条反馈：模型出方案 → 服务端校验执行 → 写回复与状态。
+ *
+ * 永远返回 FeedbackAiResult，不抛异常；任何失败都变成
+ * outcome='failed'/'unsupported' + 可读的中文分析与建议。
+ */
+export async function processFeedbackWithAi(
+  feedbackId: string,
+  operator: SessionUser
+): Promise<FeedbackAiResult> {
+  const t0 = Date.now();
+
+  const feedback = await prisma.feedback.findFirst({
+    where: { id: feedbackId, deletedAt: null },
+    select: {
+      id: true,
+      type: true,
+      title: true,
+      detail: true,
+      pagePath: true,
+      status: true,
+      userId: true,
+      username: true,
+    },
+  });
+
+  if (!feedback) {
+    return emptyResult(
+      feedbackId,
+      'unsupported',
+      `【AI 智能处理】${NOWHERE}请刷新列表后重试。`,
+      NOWHERE,
+      Date.now() - t0
+    );
+  }
+
+  // 只能处理自己的反馈；他人的反馈仅管理员可处理（与反馈接口的列表口径一致）
+  if (feedback.userId !== operator.id && !isFeedbackAdmin(operator)) {
+    return emptyResult(
+      feedback.id,
+      'unsupported',
+      '【AI 智能处理】这条反馈不属于当前账号，暂未处理。只有管理员可以处理他人的反馈。',
+      '权限校验未通过：反馈归属与当前账号不一致。',
+      Date.now() - t0
+    );
+  }
+
+  const author = await loadAuthor(feedback.userId).catch(() => null);
+  const departments = await prisma.department
+    .findMany({ where: { status: 1 }, select: { name: true }, take: 200 })
+    .then((rows) => rows.map((d) => d.name))
+    .catch(() => []);
+
+  let plan: FeedbackPlan;
+  let fallback = false;
+  try {
+    plan = await planWithModel(feedback, author, departments);
+  } catch (e) {
+    fallback = true;
+    plan = fallbackPlan(feedback);
+    if (!(e instanceof AiError)) {
+      console.error('[feedbackAi] 模型调用异常，已使用规则兜底', e);
+    }
+  }
+
+  let exec: ExecOutcome;
+  try {
+    exec = await executePlan(plan, feedback, author, operator);
+  } catch (e) {
+    console.error('[feedbackAi] 执行异常，已转为可读失败结果', e);
+    exec = failed(
+      '系统在写入时遇到业务规则冲突',
+      [{ label: '执行处理', detail: '写入被拦截', ok: false }],
+      '执行阶段出现异常，数据没有被修改。请联系管理员核对后重试。'
+    );
+  }
+
+  // 写入反馈：结果回复 + 状态 + 未读标记（让提交者在侧边栏看到新回复）
+  let status = feedback.status;
+  try {
+    const data: Record<string, unknown> = { reply: exec.reply, readAt: null };
+    if (exec.outcome === 'done') {
+      data.status = 'resolved';
+      status = 'resolved';
+    } else if (exec.outcome === 'need_info' || exec.outcome === 'failed') {
+      data.status = 'doing';
+      status = 'doing';
+    }
+    await prisma.feedback.update({ where: { id: feedback.id }, data });
+  } catch (e) {
+    console.error('[feedbackAi] 写回反馈失败', e);
+  }
+
+  void audit({
+    module: '问题反馈',
+    action: 'AI 智能处理',
+    method: 'POST',
+    path: '/api/feedback/ai',
+    targetId: feedback.id,
+    detail: {
+      intent: plan.intent,
+      outcome: exec.outcome,
+      confidence: plan.confidence,
+      fallback,
+    },
+    userId: operator.id,
+    username: operator.username,
+  });
+
+  return {
+    feedbackId: feedback.id,
+    intent: plan.intent,
+    intentLabel: INTENT_LABEL[plan.intent],
+    confidence: plan.confidence,
+    outcome: exec.outcome,
+    outcomeLabel: OUTCOME_LABEL[exec.outcome],
+    status,
+    statusLabel: STATUS_LABEL[status] ?? STATUS_LABEL.pending,
+    analysis:
+      exec.analysis ||
+      plan.analysis ||
+      (exec.outcome === 'done'
+        ? '已按反馈完成处理。'
+        : '已完成分析，未执行数据变更。'),
+    reply: exec.reply,
+    steps: exec.steps,
+    changes: exec.changes,
+    model: AI_MODEL,
+    elapsedMs: Date.now() - t0,
+    fallback,
+  };
+}