diff --git a/package.json b/package.json
index fede2f2..a730b61 100644
--- a/package.json
+++ b/package.json
@@ -15,8 +15,9 @@
         "api:gen": "alova gen -f",
         "typecheck": "vue-tsc --noEmit",
         "test:line-offline": "esbuild tests/line-offline.test.ts --bundle --platform=node --format=esm --target=node20 --external:node:* --outfile=node_modules/.cache/line-offline.test.mjs && node node_modules/.cache/line-offline.test.mjs",
+        "test:unit": "esbuild tests/line-offline.test.ts tests/app-url.test.ts tests/flow-error.test.ts tests/assign-preview.test.ts tests/convert-roundtrip.test.ts --bundle --platform=node --format=esm --target=node20 --external:node:* --outbase=tests --outdir=node_modules/.cache/unit && node --test node_modules/.cache/unit",
         "test:component": "vitest run",
-        "test": "npm run test:line-offline && npm run test:component"
+        "test": "npm run test:unit && npm run test:component"
     },
     "dependencies": {
         "@open-file-viewer/core": "^0.1.43",
diff --git a/src/api/module/flow.ts b/src/api/module/flow.ts
index bd9fe51..cc700fd 100644
--- a/src/api/module/flow.ts
+++ b/src/api/module/flow.ts
@@ -13,8 +13,9 @@ function get<T = any>(url: string, params?: Record<string, any>): Method<T> {
 
 // alova 的请求体是 Method 构造的第 5 个参数（instance.data），不是 config 上的键：
 // 写进 config 的 body/data 都会被适配器忽略，POST 将发出空 body。
-function post<T = any>(url: string, body?: any): Method<T> {
-    return new Method<T>("POST", alovaInstance, url, {}, body);
+// 第 4 个参数 config 可带 silentBizToast：调用方自己承担错误提示时，不再叠加全局 toast。
+function post<T = any>(url: string, body?: any, config?: Record<string, any>): Method<T> {
+    return new Method<T>("POST", alovaInstance, url, config || {}, body);
 }
 
 /** 状态枚举（后端 FlwEnums 口径） */
@@ -187,12 +188,12 @@ class FlowApi {
      * 流程线级停发（T03）：整条 flowGuid 停止新发起/预览，在途实例按原版本跑完；
      * 与版本级 status 正交，返回受影响版本行数。
      */
-    defOfflineLine(flowGuid: string) {
-        return post<number>(`${ROOT}/admin/def/offlineLine`, { flowGuid });
+    defOfflineLine(flowGuid: string, config?: Record<string, any>) {
+        return post<number>(`${ROOT}/admin/def/offlineLine`, { flowGuid }, config);
     }
     /** 流程线级恢复（T03）：只恢复线可用性，不改写任何版本状态或发布内容；返回受影响版本行数 */
-    defEnableLine(flowGuid: string) {
-        return post<number>(`${ROOT}/admin/def/enableLine`, { flowGuid });
+    defEnableLine(flowGuid: string, config?: Record<string, any>) {
+        return post<number>(`${ROOT}/admin/def/enableLine`, { flowGuid }, config);
     }
     defVersions(flowGuid: string) {
         return get(`${ROOT}/admin/def/versions`, { flowGuid });
diff --git a/src/components/FlowAssignEmbed.vue b/src/components/FlowAssignEmbed.vue
new file mode 100644
index 0000000..8e82f04
--- /dev/null
+++ b/src/components/FlowAssignEmbed.vue
@@ -0,0 +1,132 @@
+<script setup lang="ts">
+/**
+ * FL 侧选人 iframe 宿主（验收 P2-2 协议收口）。
+ *
+ * 用法（业务页，不是 FL 自己的产品入口）：
+ *   <FlowAssignEmbed ref="picker" :flow-guid="guid" @confirmed="onPicked" @cancelled="onCancel" />
+ *   picker.value.open()
+ *
+ * 语义（与既定架构一致）：
+ * - 确认=把 iframe 内选择的最终结果交回宿主页面内存；宿主何时提交仍由业务调 FL 正式接口决定，
+ *   前端选择结果不是授权凭据，最终资格由 FL 服务端复核。
+ * - 取消/直接关框=只通知宿主，不改宿主已有的旧选择。
+ * - 重新打开后确认=以最近一次为准（B 替换 A）。
+ * - 收消息四道校验：event.origin、event.source（必须是本组件那个 iframe 的窗口）、
+ *   协议信封（proto/v/type）、本次 contextId；任一不过直接丢弃（旧会话迟到消息不会串台）。
+ * - 关闭即摘监听，重开换新 contextId。
+ */
+import { onBeforeUnmount, ref, watch } from "vue";
+import { Modal } from "view-ui-plus";
+import { isValidAssignMessage } from "@/utils/assignEmbed";
+import type { AssignEmbedMessage } from "@/utils/assignEmbed";
+import { toAppHashUrl } from "@/utils/appUrl";
+
+const props = defineProps<{
+    /** 要预览/选择的流程线 */
+    flowGuid: string;
+    /** 弹框标题 */
+    title?: string;
+}>();
+
+const emit = defineEmits<{
+    /** 用户在 iframe 内点了确认：assigns 为最终选择，defVersion 为预览时的版本锚 */
+    confirmed: [payload: { flowGuid: string; defVersion?: number; assigns: { nodeId: string; userIds: number[] }[] }];
+    /** 取消或宿主关框：宿主应保持原有选择，不做任何覆盖 */
+    cancelled: [];
+}>();
+
+const visible = ref(false);
+const frameUrl = ref("");
+const contextId = ref("");
+const frameEl = ref<HTMLIFrameElement | null>(null);
+/** 本次打开锁定的父↔子通道条件；非响应式：只在 open 时刷新 */
+let expectedOrigin = "";
+let listening = false;
+/** 本次会话是否已经由 iframe 明确答复过（确认/取消），用于区分"宿主自己关框" */
+let settled = false;
+
+function newContextId(): string {
+    return `c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function closeListener(): void {
+    if (listening) {
+        window.removeEventListener("message", onMessage);
+        listening = false;
+    }
+}
+
+function onMessage(ev: MessageEvent): void {
+    const msg: AssignEmbedMessage | null = isValidAssignMessage(
+        ev,
+        expectedOrigin,
+        frameEl.value?.contentWindow ?? null,
+        contextId.value,
+    );
+    if (!msg) return;
+    settled = true;
+    closeListener();
+    visible.value = false;
+    if (msg.type === "assign-cancelled") {
+        emit("cancelled");
+        return;
+    }
+    emit("confirmed", {
+        flowGuid: msg.flowGuid || props.flowGuid,
+        defVersion: msg.defVersion,
+        assigns: msg.assigns ?? [],
+    });
+}
+
+function open(): void {
+    if (!props.flowGuid) return;
+    // 重开：先摘掉上一轮监听，再换一个新的 contextId——旧 frame 的迟到消息按 context 失效
+    closeListener();
+    settled = false;
+    contextId.value = newContextId();
+    const query = `flowGuid=${encodeURIComponent(props.flowGuid)}&contextId=${encodeURIComponent(contextId.value)}`;
+    frameUrl.value = toAppHashUrl(`#/assign-preview?${query}`);
+    expectedOrigin = new URL(frameUrl.value, window.location.href).origin;
+    visible.value = true;
+    window.addEventListener("message", onMessage);
+    listening = true;
+}
+
+/** 宿主主动收起（等价于取消）：同样摘监听，避免后续消息继续影响本页 */
+function close(): void {
+    closeListener();
+    if (visible.value && !settled) emit("cancelled");
+    visible.value = false;
+}
+
+// 点遮罩/X 关闭走这里；已 settled 的关闭由 iframe 自己回过话，不再补发 cancelled
+watch(visible, (val) => {
+    if (!val) closeListener();
+});
+
+onBeforeUnmount(closeListener);
+
+defineExpose({ open, close, contextId });
+</script>
+
+<template>
+    <Modal v-model="visible" :title="title || '选择办理人'" :width="760" :footer-hide="true" class="assign-embed-modal">
+        <iframe
+            v-if="frameUrl"
+            ref="frameEl"
+            :src="frameUrl"
+            class="assign-embed-frame"
+            frameborder="0"
+            title="选择办理人"
+        />
+    </Modal>
+</template>
+
+<style scoped>
+.assign-embed-frame {
+    width: 100%;
+    height: 460px;
+    border: 0;
+    display: block;
+}
+</style>
diff --git a/src/components/layout.vue b/src/components/layout.vue
index 01ff4dc..c9782a6 100644
--- a/src/components/layout.vue
+++ b/src/components/layout.vue
@@ -76,10 +76,15 @@ const routeChange = (to: any) => {
     const navArr: any[] = [];
 
     // 优先按 path 匹配菜单（平台模块 id 与路由 meta.modId 不保证一致），
-    // 匹配不到再退回 modId 对照
+    // 匹配不到再退回 modId 对照。
+    // modId 为空时必须短路：深链页（/diagram、/assign-preview、/task/*）不带 modId，
+    // 原先 `x.modId === undefined` 会命中第一条同样没有 modId 的菜单，面包屑于是显示成
+    // 不相干的「流程编辑器」（验收报告 P3）。
     const find: any =
         menuArr.value.find((x: any) => x.page && x.page === to.path) ||
-        menuArr.value.find((x: any) => x.modId === modId);
+        (modId !== undefined && modId !== null
+            ? menuArr.value.find((x: any) => x.modId === modId)
+            : null);
     if (find) {
         currPath.value = find.page || "";
         if (find.pid) {
@@ -109,7 +114,10 @@ const routeChange = (to: any) => {
         }
     }
 
-    const r = router.getRoutes().find((rt: any) => (rt.meta as any)?.modId === modId);
+    // 同上：modId 缺失时不做这条兜底，否则又是"第一条无 modId 路由"中奖
+    const r = (modId === undefined || modId === null)
+        ? undefined
+        : router.getRoutes().find((rt: any) => (rt.meta as any)?.modId === modId);
     if (r) {
         currPath.value = r.path;
         navPath.value = [{ name: (r.meta as any).title, page: r.path }];
@@ -117,7 +125,10 @@ const routeChange = (to: any) => {
     }
 
     currPath.value = "";
-    navPath.value = [];
+    // 深链页（/diagram 流程示意图、/assign-preview 选择办理人、/task/*）不挂菜单：
+    // 面包屑退回平台应用名（FL 配置的是「流程编辑器」），与实际页面标题不符（验收报告 P3）。
+    // 菜单匹配不上时至少给出本页 meta.title，父级缺失不再伪造。
+    navPath.value = title ? [{ name: title }] : [];
 };
 
 const linkMenu = (item: any) => {
diff --git a/src/utils/alova/alova-core.ts b/src/utils/alova/alova-core.ts
index 9a01f9c..d9ca816 100644
--- a/src/utils/alova/alova-core.ts
+++ b/src/utils/alova/alova-core.ts
@@ -34,6 +34,13 @@ const defHooks: Required<RequestHooks> = {
 };
 
 /* ============= 错误处理（原 axios 逻辑平移） ============= */
+/** 抛错时把契约里的码/状态挂到 Error 上：调用方可按码分支，而不是回头猜文案 */
+function fail(message: string, extra: Record<string, unknown>): never {
+    const err = new Error(message) as Error & Record<string, unknown>;
+    Object.assign(err, extra);
+    throw err;
+}
+
 function errorHandle<T>(res: BschResponse<T>, status: number): T {
     // http 层错误
     if (status !== 200) {
@@ -48,7 +55,7 @@ function errorHandle<T>(res: BschResponse<T>, status: number): T {
             default:
                 msg = res?.msg || "内部服务错误！";
         }
-        throw new Error(msg);
+        fail(msg, { httpStatus: status });
     }
 
     // 业务层错误
@@ -64,9 +71,9 @@ function errorHandle<T>(res: BschResponse<T>, status: number): T {
             window.location.href = res.urlToRedirectTo!;
             return new Promise(() => {}) as T;
         case 4:
-            throw new Error(res.msg || "参数错误!");
+            throw Object.assign(new Error(res.msg || "参数错误!"), { bizCode: 4 });
         default:
-            throw new Error(res.msg || "业务错误");
+            throw Object.assign(new Error(res.msg || "业务错误"), { bizCode: res.code });
     }
 }
 
@@ -108,7 +115,12 @@ export function createBschAlova(
     }
 
     /* ---- 响应拦截 ---- */
-    async function onSuccess(response: Response) {
+    /** 调用方自带错误面（如线级启停要报"停发失败：xxx"）时，用它跳过全局 toast，避免同一失败弹两条 */
+    function isSilentBizToast(method?: Method<any>): boolean {
+        return !!(method as unknown as { config?: Record<string, any> })?.config?.silentBizToast;
+    }
+
+    async function onSuccess(response: Response, method?: Method<any>) {
         reqCount--;
         if (reqCount === 0) {
             clearTimeout(timer);
@@ -120,18 +132,18 @@ export function createBschAlova(
         } catch (e: any) {
             console.log(e);
 
-            onBizError(e.message);
+            if (!isSilentBizToast(method)) onBizError(e.message);
             return Promise.reject(e);
         }
     }
 
-    async function onError(err: any) {
+    async function onError(err: any, method?: Method<any>) {
         reqCount = 0;
         clearTimeout(timer);
         onLoadingEnd();
 
         const msg = err?.message || "网络请求出错";
-        onHttpError(msg);
+        if (!isSilentBizToast(method)) onHttpError(msg);
         return Promise.reject(err);
     }
 
diff --git a/src/utils/alova/alova-iview.ts b/src/utils/alova/alova-iview.ts
index 2d5a9b2..97d0347 100644
--- a/src/utils/alova/alova-iview.ts
+++ b/src/utils/alova/alova-iview.ts
@@ -2,6 +2,7 @@
 import { createBschAlova } from "./alova-core";
 import { Message } from "view-ui-plus";
 import conf from "@/assets/config/host.config";
+import { describeFlowError } from "@/utils/flowError";
 
 /* 全局 loading 遮罩实例 */
 let spinInstance: any = null;
@@ -30,11 +31,13 @@ export const alovaInstance = createBschAlova(baseUrl, {
         spinInstance = Message.loading("加载中...");
     },
     onLoadingEnd: closeLoading,
+    /* 全局兜底提示：具体业务 msg 原样透出，通用/异常形态换成不误导的用户话术（不泄露堆栈/SQL/令牌） */
     onBizError(msg: string) {
-        if (!!msg) Message.error(msg);
+        const text = describeFlowError(msg);
+        if (!!text) Message.error(text);
     },
 
     onHttpError(msg: string) {
-        Message.error({ title: "网络错误", content: msg });
+        Message.error({ title: "请求未完成", content: describeFlowError(msg) });
     },
 });
diff --git a/src/utils/appUrl.ts b/src/utils/appUrl.ts
new file mode 100644
index 0000000..5b95a10
--- /dev/null
+++ b/src/utils/appUrl.ts
@@ -0,0 +1,13 @@
+/**
+ * 整页跳转用的应用内地址（hash 路由）。
+ *
+ * 线上缺陷（FL上线独立验收报告 P1-3）：入口把 `router.resolve(...).href`（自带前导 `#`）当成
+ * path 再拼一次，得到 `index.html#/task/339#/diagram?…` 双 hash——浏览器只认第一个 `#`，
+ * 页面停在原路由且无任何报错；另一处用 `origin + BASE_URL` 拼基址，BASE_URL 构建期是 "./"，
+ * 拼出 `https://host./#/diagram?…`（域名尾点）。
+ * 统一口径：先丢掉当前地址里已有的 hash 段，再接上目标路由解析出的唯一 hash。
+ */
+export function toAppHashUrl(hashHref: string, currentHref: string = window.location.href): string {
+    const hash = hashHref.startsWith("#") ? hashHref : `#${hashHref}`;
+    return `${currentHref.split("#")[0]}${hash}`;
+}
diff --git a/src/utils/flowError.ts b/src/utils/flowError.ts
new file mode 100644
index 0000000..0c4c6a8
--- /dev/null
+++ b/src/utils/flowError.ts
@@ -0,0 +1,75 @@
+/**
+ * 服务端错误文案的可读化（FL上线独立验收报告 P0-1 附带项：审批失败只甩「内部服务错误」）。
+ *
+ * 边界：前端只做**文案呈现**，不猜原因、不绕校验、不把失败说成成功。
+ * 后端把某类失败收敛成具体业务码 + 人话 msg 后（如 D09「无激活凭据」），这些 msg 原样透出即可；
+ * 仍然只给通用占位文案（code=6 内部服务错误）或异常/SQL/令牌形态的原文时，一律换成不误导的
+ * 通用提示，原文不进 DOM——堆栈、SQL、Token 不外泄。
+ */
+
+/** 后端/网关的通用占位文案：出现即说明没有可用诊断信息，需要换成不误导的用户话术 */
+const GENERIC_HINTS = [
+    "内部服务错误",
+    "服务器错误",
+    "系统错误",
+    "系统异常",
+    "业务错误",
+    "未知错误",
+    "服务异常",
+    "请求失败",
+    "null",
+];
+
+/** 明显是异常原文而不是用户文案的形态：关键字命中即按通用提示处理，不回显原文 */
+const INTERNAL_SHAPES = [
+    /exception/i,
+    /\bat\s+[a-z]+\.[a-z]+\./i,
+    /java\./i,
+    /sql/i,
+    /error code \[?\d+/i,
+    /caused by/i,
+    /stack/i,
+    /token|bearer|authorization|secret|password/i,
+    /<\s*(html|!doctype)/i,
+    /^\s*\{[\s\S]*["']?(status|error|traceback)["']?\s*[:=]/i,
+];
+
+/** 网络/会话层：alova 封装把非 200 与 fetch 失败都收敛成这几句 */
+const NETWORK_SHAPES = [/^网络错误/, /网络请求出错/, /failed to fetch/i, /fetch failed/i, /network/i, /timeout/i];
+
+export const FLOW_GENERIC_FALLBACK =
+    "服务未能处理本次请求，操作没有生效。可稍后重试；多次失败请联系流程管理员，并提供操作时间。";
+
+export const FLOW_NETWORK_FALLBACK = "网络连接异常，或登录状态已失效，请刷新页面后重试。";
+
+function looksGeneric(raw: string): boolean {
+    const t = raw.trim();
+    if (!t) return true;
+    if (GENERIC_HINTS.some((g) => t === g || t === `${g}！` || t === `${g}!`)) return true;
+    return INTERNAL_SHAPES.some((re) => re.test(t));
+}
+
+function looksNetwork(raw: string): boolean {
+    return NETWORK_SHAPES.some((re) => re.test(raw.trim()));
+}
+
+/**
+ * 业务失败 → 用户可读文案。
+ * 已在契约里的具体业务 msg（如「流程线不存在：xxx」「该任务已被办理」）原样返回，不做改写；
+ * 通用/异常形态返回兜底话术。
+ */
+export function describeFlowError(raw: unknown): string {
+    const text = typeof raw === "string"
+        ? raw
+        : raw && typeof raw === "object" && "message" in raw
+            ? String((raw as { message?: unknown }).message ?? "")
+            : "";
+    if (looksNetwork(text)) return FLOW_NETWORK_FALLBACK;
+    if (looksGeneric(text)) return FLOW_GENERIC_FALLBACK;
+    return text.trim();
+}
+
+/** 页面内联提示用：动作名 + 可读原因 + 下一步（不重复弹全局 toast） */
+export function flowFailTip(action: string, raw: unknown): string {
+    return `${action}未完成：${describeFlowError(raw)}`;
+}
diff --git a/src/views/flow/AssignPreview.vue b/src/views/flow/AssignPreview.vue
index fdc229e..e054f76 100644
--- a/src/views/flow/AssignPreview.vue
+++ b/src/views/flow/AssignPreview.vue
@@ -51,8 +51,9 @@ async function onConfirm(): Promise<void> {
   submitting.value = true;
   try {
     const invalid = selector.validate();
-    if (invalid && invalid.length) {
-      error.value = invalid[0].text || invalid[0];
+    // validate() 返回的是错误文案字符串（空串=通过）：早先按数组取值会把提示截成第一个字符
+    if (invalid) {
+      error.value = invalid;
       return;
     }
     const preview = await flowApi.applyPreview(flowGuid.value).send();
diff --git a/src/views/flow/TaskHandle.vue b/src/views/flow/TaskHandle.vue
index f46dc6d..0cf4d5a 100644
--- a/src/views/flow/TaskHandle.vue
+++ b/src/views/flow/TaskHandle.vue
@@ -9,6 +9,8 @@ import { Message, Modal } from "view-ui-plus";
 import { flowApi, INSTANCE_STATUS } from "@/api/module/flow";
 import TraceTimeline from "@/views/flow/components/TraceTimeline.vue";
 import { isBareTaskRoute, postToParent, type FlowEmbedAction } from "@/utils/taskEmbed";
+import { toAppHashUrl } from "@/utils/appUrl";
+import { flowFailTip } from "@/utils/flowError";
 
 const route = useRoute();
 const router = useRouter();
@@ -22,6 +24,8 @@ const taskId = computed(() => String(route.params.taskId || ""));
 const isBare = computed(() => isBareTaskRoute(route.path, route.query.embed));
 /** bare 下办理成功后的结果条文案（不跳走，父页面自己决定关不关） */
 const doneTip = ref("");
+/** 办理失败的内联提示：全局 toast 只说服务端给的那句，这里补「哪个动作没生效 + 现在该怎么办」 */
+const failTip = ref("");
 
 /** 轨迹显示口径：dept=按科室 / user=按人员（不传=人员），与办件详情页、图示页同参数 */
 const mode = ref<string>(route.query.mode === "dept" ? "dept" : "user");
@@ -130,9 +134,17 @@ function openBizUrl() {
 
 /** 流程图仍要能看，但 bare 下不能用 router.push——/diagram 不是 /task/ 前缀，会在 iframe 里长出菜单壳 */
 function openDiagram() {
-    const href = router.resolve(`/diagram?instanceId=${detail.value.instanceId}&mode=${mode.value}`).href;
-    if (isBare.value) window.open(href, "_blank");
-    else router.push(href);
+    const target = {
+        path: "/diagram",
+        query: { instanceId: String(detail.value.instanceId), mode: mode.value },
+    };
+    if (isBare.value) {
+        // 新窗口整页打开：地址必须只剩一个 hash（把 resolve 出的 "#/diagram?…" 直接当 path
+        // 会在当前地址后面长出第二个 hash，页面原地不动且不报错——线上 P1-3 即此）
+        window.open(toAppHashUrl(router.resolve(target).href), "_blank");
+        return;
+    }
+    router.push(target);
 }
 
 /**
@@ -157,6 +169,8 @@ async function submit(approved: boolean) {
         return;
     }
     submitting.value = true;
+    failTip.value = "";
+    const label = approved ? "同意" : "拒绝";
     try {
         if (approved) {
             // 多出口节点必须带所选出口
@@ -174,6 +188,9 @@ async function submit(approved: boolean) {
             Message.success("已拒绝");
             await afterHandled("reject", "已拒绝，本任务办理完成");
         }
+    } catch (e: any) {
+        // 失败就是失败：不跳走、不清意见、不写成功文案；服务端事务已回滚，任务仍是待办
+        failTip.value = flowFailTip(label, e);
     } finally {
         submitting.value = false;
     }
@@ -215,6 +232,7 @@ function openReturn() {
 
 function doReturn() {
     submitting.value = true;
+    failTip.value = "";
     const targets = detail.value?.returnTargets || [];
     const known = targets.find((t: any) => String(t.nodeId) === returnTarget.value) ||
         targets[targets.length - 1] || null;
@@ -225,6 +243,7 @@ function doReturn() {
             showReturn.value = false;
             await afterHandled("return", "已退回，目标节点重新生成待办");
         })
+        .catch((e: any) => { failTip.value = flowFailTip("退回", e); })
         .finally(() => { submitting.value = false; });
 }
 
@@ -236,12 +255,15 @@ async function doTransfer() {
         return;
     }
     submitting.value = true;
+    failTip.value = "";
     try {
         // 姓名由后端 AssigneeResolver 严格解析（查不到会拒绝，前端不信任输入）
         await flowApi.transfer(myTaskId.value, uid, opinion.value.trim() || undefined).send();
         Message.success("已移交");
         showTransfer.value = false;
         await afterHandled("transfer", "已移交，本任务由接手人办理");
+    } catch (e: any) {
+        failTip.value = flowFailTip("移交", e);
     } finally {
         submitting.value = false;
     }
@@ -331,6 +353,10 @@ onBeforeUnmount(() => {
             </div>
             <Input v-model="opinion" type="textarea" :rows="3" maxlength="500" show-word-limit
                    placeholder="同意可选填意见；拒绝必须填写意见" />
+            <Alert v-if="failTip" type="error" show-icon class="fail-tip">
+                {{ failTip }}
+                <div class="muted">本次办理未生效，任务仍是你的待办；可稍后重试，或把页面提示与操作时间反馈给流程管理员。</div>
+            </Alert>
             <div class="actions" v-if="myTaskId">
                 <template v-if="confirming">
                     <span class="confirm-tip">同意该任务？</span>
@@ -444,6 +470,8 @@ onBeforeUnmount(() => {
 /* 去壳态：iframe 里父页面已给了标题与外边距，这里只留最小呼吸（也稳住高度上报的抖动） */
 .page.bare { padding: 8px 10px; }
 .done-tip { margin-bottom: 10px; }
+.fail-tip { margin: 10px 0 0; }
+.fail-tip .muted { margin-top: 4px; font-size: 12px; }
 .head { display: flex; align-items: center; gap: 8px; margin-bottom: 12px; }
 .title { font-size: 16px; font-weight: 600; }
 .block { margin-bottom: 12px; }
diff --git a/src/views/flow/admin/Defs.vue b/src/views/flow/admin/Defs.vue
index a8b983c..f7a99dd 100644
--- a/src/views/flow/admin/Defs.vue
+++ b/src/views/flow/admin/Defs.vue
@@ -412,8 +412,8 @@ async function applyLineAction(row: any, action: "offline" | "enable") {
             lineOffline: Number(row.lineOffline) || 0,
             action,
             request: async (guid) => Number(await (action === "offline"
-                ? flowApi.defOfflineLine(guid).send()
-                : flowApi.defEnableLine(guid).send())) || 0,
+                ? flowApi.defOfflineLine(guid, { silentBizToast: true }).send()
+                : flowApi.defEnableLine(guid, { silentBizToast: true }).send())) || 0,
             reload: () => load(),
         });
         if (out.kind === "skipped") {
diff --git a/src/views/flow/admin/def-editor/assignPreview.ts b/src/views/flow/admin/def-editor/assignPreview.ts
new file mode 100644
index 0000000..434028f
--- /dev/null
+++ b/src/views/flow/admin/def-editor/assignPreview.ts
@@ -0,0 +1,226 @@
+/**
+ * 审批节点「预览候选人」（FL上线独立验收报告 P2-1：/assign-preview 页存在但编辑器内无入口）。
+ *
+ * 口径：
+ * - 只读。解析当前抽屉里的**草稿配置**，不写回节点、不改流程定义、不建实例。
+ * - 数据全部来自既有接口（科室成员 / UserBase 用户检索 / 发起预览），前端不重实现人员解析：
+ *   DEPT_KEY 读的是后端 AssigneeResolver 同一张 flw_dept_member，USERS 读的是 UserBase byId。
+ * - 最终办理资格仍由 FL 服务端在正式发起/办理时复核（跨校、禁用、非本人等），这里只是设计期核对。
+ */
+import { describeFlowError } from "@/utils/flowError";
+
+export type PreviewAssigneeType = "DEPT_KEY" | "USERS";
+
+export interface PreviewAssignPolicy {
+    mode?: string;
+    min?: number | null;
+    max?: number | null;
+    required?: boolean;
+}
+
+/** 抽屉里的当前（可能未保存）节点配置 */
+export interface PreviewNodeConfig {
+    uid: string;
+    name: string;
+    type: PreviewAssigneeType;
+    deptKey: string;
+    userIds: number[];
+    countersign: "ALL" | "ANY";
+    assignPolicy: PreviewAssignPolicy | null | undefined;
+}
+
+export interface PreviewDept {
+    deptKey: string;
+    deptName: string;
+    count: number;
+}
+
+export interface CandidateRow {
+    userId: number;
+    userName: string;
+    /** 该候选人不计入/存在风险的说明；空=正常 */
+    warn?: string;
+}
+
+/** 已发布版本的发起预览对账结果 */
+export interface PublishedView {
+    state: "ok" | "missing" | "unavailable";
+    defVersion?: number;
+    rows: CandidateRow[];
+    text: string;
+}
+
+export interface NodePreviewResult {
+    /** 是否解析出了可用候选人（false 时一定有 blocked 或 published.unavailable 解释） */
+    ok: boolean;
+    headline: string;
+    rows: CandidateRow[];
+    blocked?: string;
+    published?: PublishedView;
+    notes: string[];
+}
+
+export interface PreviewApi {
+    deptMembers: (deptId: string) => Promise<any[]>;
+    lookupUser: (userId: number) => Promise<any>;
+    applyPreview: (flowGuid: string) => Promise<any>;
+}
+
+/** flw_dept_member.status / flw_dept.status：0=启用（与后端 resolveEnabled 同口径） */
+const DEPT_MEMBER_ENABLED = 0;
+
+function countersignText(c: "ALL" | "ANY"): string {
+    return c === "ALL" ? "会签（全部同意才通过）" : "或签（任一人同意即通过）";
+}
+
+function assignPolicyText(p: PreviewAssignPolicy | null | undefined): string {
+    if (!p) return "";
+    const mode = p.mode === "SINGLE" ? "单选 1 人" : `多选 ${p.min ?? 1}~${p.max ?? "不限"} 人`;
+    return `；发起时指派：${mode}${p.required ? " · 必选" : ""}`;
+}
+
+/** UserBase BoaUser.status：1=启用（后端 D11 终审按此拒绝禁用/未知状态账号） */
+function userRow(u: any, id: number): CandidateRow {
+    if (!u) return { userId: id, userName: `#${id}`, warn: "UserBase 查不到该用户，正式发起时会被拒绝" };
+    const status = typeof u.status === "number" ? u.status : null;
+    return {
+        userId: id,
+        userName: u.name || `#${id}`,
+        warn: status === 1 ? undefined : `账号状态${status == null ? "未知" : status}（非启用），正式办理时会被服务端拒绝`,
+    };
+}
+
+async function deptRows(deptKey: string, api: PreviewApi): Promise<CandidateRow[]> {
+    const members = (await api.deptMembers(deptKey)) || [];
+    return members.map((m: any) => ({
+        userId: Number(m.userId),
+        userName: m.userName || `#${m.userId}`,
+        warn: Number(m.status) === DEPT_MEMBER_ENABLED ? undefined : "该成员已停用，不计入候选",
+    }));
+}
+
+/** 已发布版本对账：只有本线已保存（有 flowGuid）时才有可比对象 */
+export async function loadPublishedView(
+    cfg: PreviewNodeConfig,
+    flowGuid: string,
+    api: PreviewApi,
+): Promise<PublishedView> {
+    if (!flowGuid) {
+        return { state: "unavailable", rows: [], text: "本流程线尚未保存，没有可比对的已发布版本（预览按当前草稿配置解析）。" };
+    }
+    let res: any;
+    try {
+        res = await api.applyPreview(flowGuid);
+    } catch (e: any) {
+        return { state: "unavailable", rows: [], text: `已发布版本预览不可用：${describeFlowError(e)}` };
+    }
+    const version = Number(res?.defVersion) || undefined;
+    const hit = (res?.nodes || []).find((n: any) => String(n.nodeId) === String(cfg.uid));
+    if (!hit) {
+        return {
+            state: "missing",
+            defVersion: version,
+            rows: [],
+            text: `已发布版本 v${version ?? "?"} 的发起预览里没有本节点：要么它未开启发起时指派，要么是尚未发布的草稿节点。`,
+        };
+    }
+    const rows: CandidateRow[] = (hit.candidates || []).map((c: any) => ({
+        userId: Number(c.userId),
+        userName: c.userName || `#${c.userId}`,
+    }));
+    return {
+        state: "ok",
+        defVersion: version,
+        rows,
+        text: `已发布版本 v${version ?? "?"} 解析出的可指派候选人（发起人实际可选范围以此为准，本节点${rows.length ? "" : "当前无候选人"}）。`,
+    };
+}
+
+/**
+ * 解析当前节点配置的候选人。
+ * depts 传编辑器的科室上下文（含启用人数），用于把「科室不存在/0 人」讲清楚而不靠猜。
+ */
+export async function resolveNodePreview(
+    cfg: PreviewNodeConfig,
+    depts: PreviewDept[],
+    api: PreviewApi,
+    flowGuid = "",
+): Promise<NodePreviewResult> {
+    const notes = [
+        `多人审批方式：${countersignText(cfg.countersign)}${assignPolicyText(cfg.assignPolicy)}`,
+        "预览只读：不写回节点、不改动流程定义；最终办理资格由 FL 服务端在正式发起时复核。",
+    ];
+    const published = await loadPublishedView(cfg, flowGuid, api);
+
+    if (cfg.type === "DEPT_KEY") {
+        if (!cfg.deptKey) {
+            return { ok: false, headline: "按科室映射解析", rows: [], blocked: "尚未选择科室映射，请先在「科室映射」里选一个科室。", published, notes };
+        }
+        const dept = depts.find((d) => d.deptKey === cfg.deptKey);
+        if (!dept) {
+            return {
+                ok: false,
+                headline: "按科室映射解析",
+                rows: [],
+                blocked: `科室映射「${cfg.deptKey}」不在本校科室列表中（可能已删除），发布会被拦截。`,
+                published,
+                notes,
+            };
+        }
+        let rows: CandidateRow[];
+        try {
+            rows = await deptRows(cfg.deptKey, api);
+        } catch (e: any) {
+            return {
+                ok: false,
+                headline: `科室「${dept.deptName || dept.deptKey}」`,
+                rows: [],
+                blocked: `读取科室成员失败：${describeFlowError(e)}`,
+                published,
+                notes,
+            };
+        }
+        const enabled = rows.filter((r) => !r.warn);
+        if (!enabled.length) {
+            return {
+                ok: false,
+                headline: `科室「${dept.deptName || dept.deptKey}」（${dept.deptKey}）`,
+                rows,
+                blocked: `科室「${dept.deptName || dept.deptKey}」当前 0 名启用办理人，发布会被拦截；请到「办理人映射」补人。`,
+                published,
+                notes,
+            };
+        }
+        if (rows.length !== enabled.length) {
+            notes.unshift(`共 ${rows.length} 名成员，其中 ${enabled.length} 名启用（停用成员已在下表标注）。`);
+        }
+        return {
+            ok: true,
+            headline: `科室「${dept.deptName || dept.deptKey}」（${dept.deptKey}）· ${enabled.length} 名启用办理人`,
+            rows,
+            published,
+            notes,
+        };
+    }
+
+    if (!cfg.userIds.length) {
+        return { ok: false, headline: "按指定用户解析", rows: [], blocked: "尚未选择用户，请先点「选择用户」添加审批人。", published, notes };
+    }
+    const rows: CandidateRow[] = [];
+    for (const id of cfg.userIds) {
+        try {
+            rows.push(userRow(await api.lookupUser(Number(id)), Number(id)));
+        } catch (e: any) {
+            rows.push({ userId: Number(id), userName: `#${id}`, warn: `用户检索失败：${describeFlowError(e)}` });
+        }
+    }
+    const usable = rows.filter((r) => !r.warn);
+    return {
+        ok: usable.length > 0,
+        headline: `指定用户 · ${rows.length} 人（${usable.length} 人可检索到且状态启用）`,
+        rows,
+        blocked: usable.length ? undefined : "指定的用户全部查不到或状态非启用，发布会被拦截。",
+        published,
+        notes,
+    };
+}
diff --git a/src/views/flow/admin/def-editor/components/ApprovalDrawer.vue b/src/views/flow/admin/def-editor/components/ApprovalDrawer.vue
index fa3d691..66d2364 100644
--- a/src/views/flow/admin/def-editor/components/ApprovalDrawer.vue
+++ b/src/views/flow/admin/def-editor/components/ApprovalDrawer.vue
@@ -6,6 +6,8 @@ import { computed, inject, reactive, ref, watch } from "vue";
 import { Message } from "view-ui-plus";
 import UserCheckModal from "@/components/UserCheckModal.vue";
 import { flowApi } from "@/api/module/flow";
+import AssigneePreviewModal from "./AssigneePreviewModal.vue";
+import type { PreviewNodeConfig } from "../assignPreview";
 import { ApprovalNode, EDITOR_CTX, createApproval } from "../model";
 
 const props = defineProps<{
@@ -114,6 +116,49 @@ function removeUser(id: number): void {
     if (i >= 0) form.userIds.splice(i, 1);
 }
 
+// ===== 高级设置分层（P2 核心/高级）：只挪位置，不改字段、不改数据语义 =====
+/** 高级区是否展开；打开抽屉时若已有高级配置则默认展开，避免"配了但看不见" */
+const advOpen = ref(false);
+const activeAdvanced = computed(() => {
+    const hits: string[] = [];
+    if (form.countersign === "ALL") hits.push("会签");
+    if (form.assignEnabled) hits.push("发起时指派");
+    if (form.deadlineHours) hits.push("办理时限");
+    if (form.multiOutlet) hits.push("多出口");
+    return hits;
+});
+
+watch(() => [props.modelValue, props.node?.uid], () => {
+    if (props.modelValue) advOpen.value = activeAdvanced.value.length > 0;
+}, { immediate: true });
+
+// ===== 指派预览（验收 P2-1：编辑器内要有可发现入口） =====
+const previewModal = ref<any>();
+
+/** 用抽屉里的实时表单（含未保存改动）作为预览输入；预览全程只读，不回写节点 */
+function previewConfig(): PreviewNodeConfig {
+    return {
+        uid: props.node?.uid || "",
+        name: form.name,
+        type: form.type,
+        deptKey: form.deptKey,
+        userIds: [...form.userIds],
+        countersign: form.countersign,
+        assignPolicy: form.assignEnabled
+            ? {
+                  mode: form.assignMode,
+                  min: form.assignMin,
+                  max: form.assignMax,
+                  required: form.assignRequired,
+              }
+            : null,
+    };
+}
+
+function onPreviewCandidates(): void {
+    previewModal.value?.show(previewConfig(), ctx.depts, ctx.flowGuid);
+}
+
 function onOk(): void {
     const n = props.node;
     if (!n) {
@@ -206,6 +251,20 @@ function onRemove(): void {
                 </div>
             </template>
 
+            <!-- 候选人预览：核心区入口（读当前配置，不保存、不改动定义） -->
+            <div class="fld">
+                <Button size="small" type="primary" ghost @click="onPreviewCandidates">预览候选人</Button>
+                <div class="hint">按当前配置（含未保存改动）解析实际会拿到待办的人，并与已发布版本对账；最终资格由服务端在正式发起时复核</div>
+            </div>
+
+            <!-- 高级能力：默认收起，已配置时自动展开并在收起态标出条目（不删除、不改语义） -->
+            <div class="adv-head" @click="advOpen = !advOpen">
+                <span class="adv-caret">{{ advOpen ? "▾" : "▸" }}</span>
+                <span class="adv-title">高级设置</span>
+                <span v-if="!advOpen && activeAdvanced.length" class="adv-badge">已配置 {{ activeAdvanced.join("、") }}</span>
+                <span v-else-if="!advOpen" class="adv-sub">会签/或签 · 发起时指派 · 办理时限 · 多出口路由</span>
+            </div>
+            <div v-show="advOpen" class="adv-body">
             <div class="fld">
                 <label>多人审批方式</label>
                 <RadioGroup v-model="form.countersign" type="button" button-style="solid">
@@ -260,6 +319,7 @@ function onRemove(): void {
                     关闭请用泳道头部的"恢复单出口"（需处理泳道内容去向）
                 </div>
             </div>
+            </div>
         </Form>
 
         <div class="dw-foot">
@@ -278,6 +338,8 @@ function onRemove(): void {
         :userids="form.userIds"
         @on-submit="onUsersPicked"
     />
+
+    <AssigneePreviewModal ref="previewModal" />
 </template>
 
 <style scoped>
@@ -302,6 +364,32 @@ function onRemove(): void {
 .hint.warn {
     color: #ff9900;
 }
+.adv-head {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 0;
+    margin: 4px 0 12px;
+    border-top: 1px dashed #e8eaec;
+    cursor: pointer;
+    user-select: none;
+}
+.adv-title {
+    font-weight: 600;
+    font-size: 13px;
+}
+.adv-sub,
+.adv-badge {
+    font-size: 12px;
+    color: #808695;
+}
+.adv-badge {
+    color: #ff9900;
+}
+.adv-body {
+    padding-left: 10px;
+    border-left: 2px solid #f0f0f0;
+}
 .user-add {
     display: flex;
     gap: 8px;
diff --git a/src/views/flow/admin/def-editor/components/AssigneePreviewModal.vue b/src/views/flow/admin/def-editor/components/AssigneePreviewModal.vue
new file mode 100644
index 0000000..e16c3d7
--- /dev/null
+++ b/src/views/flow/admin/def-editor/components/AssigneePreviewModal.vue
@@ -0,0 +1,91 @@
+<script setup lang="ts">
+/**
+ * 审批节点候选人预览弹窗（编辑器内入口，验收报告 P2-1）。
+ * 只读展示 resolveNodePreview 的结果：草稿解析 + 已发布版本对账 + 明确的不可预览原因。
+ * 关闭不做任何写回——它只接收抽屉里的本地表单快照。
+ */
+import { ref } from "vue";
+import { Modal, Alert, Tag, Button } from "view-ui-plus";
+import { resolveNodePreview, type PreviewApi, type PreviewDept, type PreviewNodeConfig } from "../assignPreview";
+import { flowApi } from "@/api/module/flow";
+
+const api: PreviewApi = {
+    deptMembers: (deptId) => flowApi.deptMembers(deptId).send() as Promise<any[]>,
+    lookupUser: (userId) => flowApi.mapLookupUser(userId).send() as Promise<any>,
+    applyPreview: (flowGuid) => flowApi.applyPreview(flowGuid).send() as Promise<any>,
+};
+
+const visible = ref(false);
+const loading = ref(false);
+const title = ref("预览候选人");
+const result = ref<Awaited<ReturnType<typeof resolveNodePreview>> | null>(null);
+
+async function show(cfg: PreviewNodeConfig, depts: PreviewDept[], flowGuid = ""): Promise<void> {
+    visible.value = true;
+    loading.value = true;
+    result.value = null;
+    title.value = `预览候选人 · ${cfg.name || "未命名节点"}`;
+    try {
+        result.value = await resolveNodePreview(cfg, depts, api, flowGuid);
+    } finally {
+        loading.value = false;
+    }
+}
+
+defineExpose({ show });
+</script>
+
+<template>
+    <Modal v-model="visible" :title="title" :width="620" :footer-hide="true">
+        <div v-if="loading" class="muted" style="padding: 24px 0; text-align: center">正在解析候选人…</div>
+        <template v-else-if="result">
+            <Alert v-if="result.blocked" type="warning" show-icon class="pv-block">{{ result.blocked }}</Alert>
+            <div class="pv-headline">
+                <b>{{ result.headline }}</b>
+                <span class="pv-source">数据源：{{ result.rows.length ? "FL 科室映射 / UserBase 既有接口" : "未取到候选" }}</span>
+            </div>
+            <div v-if="result.rows.length" class="pv-rows">
+                <div v-for="r in result.rows" :key="r.userId" class="pv-row">
+                    <Tag :color="r.warn ? 'warning' : 'blue'">{{ r.userName }}</Tag>
+                    <span class="pv-id">#{{ r.userId }}</span>
+                    <span v-if="r.warn" class="pv-warn">{{ r.warn }}</span>
+                </div>
+            </div>
+            <div v-else class="muted">（本节点当前没有可展示的候选人）</div>
+
+            <div class="pv-pub" v-if="result.published">
+                <div class="pv-pub-title">已发布版本对账</div>
+                <div class="pv-pub-body">
+                    <Tag :color="result.published.state === 'ok' ? 'success' : result.published.state === 'missing' ? 'default' : 'warning'">
+                        {{ result.published.state === "ok" ? "可比对" : result.published.state === "missing" ? "草稿节点未发布" : "不可比对" }}
+                    </Tag>
+                    <span>{{ result.published.text }}</span>
+                </div>
+                <div v-if="result.published.state === 'ok' && result.published.rows.length" class="pv-rows">
+                    <Tag v-for="p in result.published.rows" :key="p.userId" color="green">{{ p.userName }}</Tag>
+                </div>
+            </div>
+
+            <ul class="pv-notes">
+                <li v-for="(n, i) in result.notes" :key="i">{{ n }}</li>
+            </ul>
+        </template>
+        <div style="margin-top: 12px; text-align: right">
+            <Button @click="visible = false">关闭</Button>
+        </div>
+    </Modal>
+</template>
+
+<style scoped>
+.pv-block { margin-bottom: 10px; }
+.pv-headline { display: flex; align-items: baseline; gap: 10px; margin-bottom: 10px; }
+.pv-source { color: #808695; font-size: 12px; }
+.pv-rows { display: flex; flex-wrap: wrap; gap: 6px 0; margin-bottom: 12px; }
+.pv-row { display: flex; align-items: center; gap: 6px; width: 100%; }
+.pv-id { color: #c5c8ce; font-size: 12px; }
+.pv-warn { color: #ff9900; font-size: 12px; }
+.pv-pub { border-top: 1px dashed #e8eaec; padding-top: 10px; margin-bottom: 10px; }
+.pv-pub-title { font-weight: 600; font-size: 13px; margin-bottom: 6px; }
+.pv-pub-body { display: flex; align-items: flex-start; gap: 8px; font-size: 13px; }
+.pv-notes { margin: 0; padding-left: 18px; color: #808695; font-size: 12px; line-height: 1.7; }
+</style>
diff --git a/src/views/flow/admin/def-editor/components/PlusButton.vue b/src/views/flow/admin/def-editor/components/PlusButton.vue
index 06c31ad..501bd62 100644
--- a/src/views/flow/admin/def-editor/components/PlusButton.vue
+++ b/src/views/flow/admin/def-editor/components/PlusButton.vue
@@ -23,6 +23,7 @@ function pick(kind: "approval" | "parallel" | "notify" | "condition"): void {
         <Poptip v-model="visible" trigger="click" placement="right-start" transfer :width="200" popper-class="def-plus-pop">
             <div class="plus-btn" title="在此插入节点">＋</div>
             <template #content>
+                <div class="menu-group">常用节点</div>
                 <div class="menu-item" @click="pick('approval')">
                     <span class="mi-icon approval">审</span>
                     <span class="mi-text">
@@ -37,6 +38,8 @@ function pick(kind: "approval" | "parallel" | "notify" | "condition"): void {
                         <i>知会指定人，不产生待办、不阻塞流程</i>
                     </span>
                 </div>
+                <!-- 高级结构：只是分组展示，四类插入能力一个都没少，插入后的 JSON 语义完全不变 -->
+                <div class="menu-group adv">高级结构</div>
                 <div class="menu-item" @click="pick('parallel')">
                     <span class="mi-icon parallel">⇉</span>
                     <span class="mi-text">
@@ -94,6 +97,17 @@ function pick(kind: "approval" | "parallel" | "notify" | "condition"): void {
     color: #fff;
     box-shadow: 0 0 0 4px rgba(45, 140, 240, 0.15);
 }
+.menu-group {
+    padding: 4px 10px 2px;
+    font-size: 11px;
+    color: #808695;
+    letter-spacing: 0.5px;
+}
+.menu-group.adv {
+    margin-top: 6px;
+    border-top: 1px dashed #e8eaec;
+    padding-top: 8px;
+}
 .menu-item {
     display: flex;
     gap: 10px;
diff --git a/src/views/flow/admin/def-editor/index.vue b/src/views/flow/admin/def-editor/index.vue
index b354cc7..b135e36 100644
--- a/src/views/flow/admin/def-editor/index.vue
+++ b/src/views/flow/admin/def-editor/index.vue
@@ -428,6 +428,10 @@ provide<EditorCtx>(EDITOR_CTX, {
     model,
     depts,
     userNames,
+    // 升版本/编辑草稿时由 defGet 带回；新建态为空串（预览据此说明"没有可比对的已发布版本"）
+    get flowGuid() {
+        return sourceFlowGuid.value || "";
+    },
     routers,
     availableVars,
     issueOf,
@@ -647,13 +651,13 @@ onUnmounted(() => window.removeEventListener("beforeunload", onBeforeUnload));
                             :disabled="!!editId || !!baseGuid" :maxlength="40" />
                     </div>
                     <div class="ip-fld">
-                        <label>归属应用 <span style="color: #ed4014">*</span></label>
-                        <Select v-model="appKey" placeholder="归属应用（必选）" filterable>
+                        <label>归属应用<span class="ip-mini">可选 · 仅作创建方筛选/审计，不是发起资格</span></label>
+                        <Select v-model="appKey" placeholder="归属应用（可留空）" filterable clearable>
                             <Option v-for="a in appOptions" :key="a.appKey" :value="a.appKey">{{ a.appName }}</Option>
                         </Select>
                     </div>
                     <div class="ip-fld">
-                        <label>关联表单<span class="ip-mini">表单中心 · 成对存版本</span></label>
+                        <label>关联表单<span class="ip-mini">可选 · 表单中心 · 成对存版本</span></label>
                         <Select :value="formUuid" clearable filterable placeholder="不关联（原生办理）"
                             :disabled="!!formCenterError" @on-change="onFormChange">
                             <Option v-for="f in formOptions" :key="f.formUuid" :value="f.formUuid">
diff --git a/src/views/flow/admin/def-editor/model.ts b/src/views/flow/admin/def-editor/model.ts
index eca2020..c58c7cf 100644
--- a/src/views/flow/admin/def-editor/model.ts
+++ b/src/views/flow/admin/def-editor/model.ts
@@ -415,6 +415,8 @@ export interface EditorCtx {
     model: EditorModel;
     depts: DeptOption[];
     userNames: Record<number, string>;
+    /** 当前流程线 flowGuid（新建/尚未保存时为空）：指派预览与已发布版本对账要用 */
+    flowGuid: string;
     /** 条件分支的判断服务注册下拉（flw_router 启用项；拉取失败为空数组，校验降级提示） */
     routers: RouterOption[];
     /** 可用变量 chips：近期办件 formData 顶层键聚合 + 内置变量（供条件表达式内联提示/插入） */
diff --git a/src/views/flow/components/InstanceDrawer.vue b/src/views/flow/components/InstanceDrawer.vue
index f0f964d..53ffe91 100644
--- a/src/views/flow/components/InstanceDrawer.vue
+++ b/src/views/flow/components/InstanceDrawer.vue
@@ -2,10 +2,14 @@
 // 办件详情抽屉（管理面列表页复用）：非 iframe，内部直接复用 InstanceBody（full 口径）。
 // 宽度与 Notice 审批记录抽屉对齐 740px；关闭后清空状态，下次打开重新加载。
 import { ref, computed, watch } from "vue";
+import { useRouter } from "vue-router";
 import { Drawer, Tag } from "view-ui-plus";
 import { flowApi, INSTANCE_STATUS, INSTANCE_STATUS_COLOR } from "@/api/module/flow";
 import InstanceBody from "@/views/flow/components/InstanceBody.vue";
 import config from "@/assets/config/host.config";
+import { toAppHashUrl } from "@/utils/appUrl";
+
+const router = useRouter();
 
 const props = defineProps<{
     modelValue: boolean;
@@ -49,8 +53,13 @@ const diagramSrc = computed(() => {
 
 function openDiagram() {
     if (!detail.value?.instanceId) return;
-    const url = `${window.location.origin}${import.meta.env.BASE_URL}#/diagram?instanceId=${detail.value.instanceId}&mode=${mode.value}`;
-    window.open(url, "_blank");
+    // 原写法 `${origin}${BASE_URL}#/diagram?…` 里 BASE_URL 构建期是 "./"，拼出
+    // `https://host./#/…`（域名尾点）；改为按当前真实地址丢 hash 再接目标 hash
+    const href = router.resolve({
+        path: "/diagram",
+        query: { instanceId: String(detail.value.instanceId), mode: mode.value },
+    }).href;
+    window.open(toAppHashUrl(href), "_blank");
 }
 
 function statusName(s: number) {
diff --git a/tests/app-url.test.ts b/tests/app-url.test.ts
new file mode 100644
index 0000000..ddba6e1
--- /dev/null
+++ b/tests/app-url.test.ts
@@ -0,0 +1,48 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { toAppHashUrl } from "../src/utils/appUrl";
+
+/** 整页跳转地址单测：只锁「最终只有一个 hash」这条线上缺陷口径，不替代浏览器实测 */
+
+test("办理页入口：resolve 出的 #/diagram 不再追加到当前 hash 之后", () => {
+    const out = toAppHashUrl(
+        "#/diagram?instanceId=107&mode=user",
+        "https://base.yhxt.com.cn/flow-center/front/index.html#/task/339",
+    );
+    assert.equal(out, "https://base.yhxt.com.cn/flow-center/front/index.html#/diagram?instanceId=107&mode=user");
+    assert.equal(out.split("#").length - 1, 1);
+});
+
+test("参数原样保留：instanceId 与 mode 不因去 hash 而丢失", () => {
+    const out = toAppHashUrl("#/diagram?instanceId=107&mode=dept", "https://h/flow-center/front/index.html#/task/339");
+    assert.match(out, /instanceId=107/);
+    assert.match(out, /mode=dept/);
+});
+
+test("无 hash 的入口地址：直接接上目标 hash", () => {
+    assert.equal(
+        toAppHashUrl("#/diagram?instanceId=1", "https://h/flow-center/front/index.html"),
+        "https://h/flow-center/front/index.html#/diagram?instanceId=1",
+    );
+});
+
+test("真实 query 保留在 hash 之前（部署带 ?v= 缓存位时不被吞）", () => {
+    assert.equal(
+        toAppHashUrl("#/diagram?instanceId=1", "https://h/index.html?v=9#/task/339"),
+        "https://h/index.html?v=9#/diagram?instanceId=1",
+    );
+});
+
+test("不带前导 # 的 resolve 结果同样归一，且不出现双 hash", () => {
+    const out = toAppHashUrl("/diagram?instanceId=1", "https://h/index.html#/task/339");
+    assert.equal(out, "https://h/index.html#/diagram?instanceId=1");
+});
+
+test("查看大图：不再用 origin+BASE_URL 拼出 host 尾点地址", () => {
+    // 旧写法 origin + "./" + "#/diagram?…" 会得到 https://base.yhxt.com.cn./#/diagram?…
+    const legacy = `${"https://base.yhxt.com.cn"}${"./"}#/diagram?instanceId=1`;
+    assert.match(legacy, /com\.cn\.\//);
+    const fixed = toAppHashUrl("#/diagram?instanceId=1", "https://base.yhxt.com.cn/flow-center/front/index.html#/admin/instances");
+    assert.ok(!/\.cn\.\//.test(fixed), fixed);
+    assert.equal(fixed, "https://base.yhxt.com.cn/flow-center/front/index.html#/diagram?instanceId=1");
+});
diff --git a/tests/assign-preview.test.ts b/tests/assign-preview.test.ts
new file mode 100644
index 0000000..64d7d3c
--- /dev/null
+++ b/tests/assign-preview.test.ts
@@ -0,0 +1,162 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { resolveNodePreview } from "../src/views/flow/admin/def-editor/assignPreview";
+import type { PreviewApi, PreviewDept, PreviewNodeConfig } from "../src/views/flow/admin/def-editor/assignPreview";
+
+/**
+ * 编辑器指派预览解析单测：断言的是「用什么接口、给什么结论、失败怎么讲」。
+ * 数据用桩，不代表真实科室数据与线上服务已验证。
+ */
+
+const depts: PreviewDept[] = [
+    { deptKey: "41", deptName: "校长室", count: 2 },
+    { deptKey: "42", deptName: "空科室", count: 0 },
+];
+
+function cfg(over: Partial<PreviewNodeConfig> = {}): PreviewNodeConfig {
+    return {
+        uid: "u3",
+        name: "科室审核",
+        type: "DEPT_KEY",
+        deptKey: "41",
+        userIds: [],
+        countersign: "ANY",
+        assignPolicy: null,
+        ...over,
+    };
+}
+
+function stubApi(over: Partial<PreviewApi> = {}): PreviewApi & { calls: string[] } {
+    const calls: string[] = [];
+    return {
+        calls,
+        deptMembers: async (deptId) => {
+            calls.push(`deptMembers:${deptId}`);
+            if (deptId === "41") {
+                return [
+                    { userId: 101, userName: "陈星", status: 0 },
+                    { userId: 102, userName: "刘文娟", status: 0 },
+                    { userId: 103, userName: "测试教师10", status: 1 },
+                ];
+            }
+            return [];
+        },
+        lookupUser: async (userId) => {
+            calls.push(`lookupUser:${userId}`);
+            if (userId === 101) return { id: 101, name: "陈星", status: 1 };
+            if (userId === 999) return null;
+            return { id: userId, name: `用户${userId}`, status: 0 };
+        },
+        applyPreview: async (flowGuid) => {
+            calls.push(`applyPreview:${flowGuid}`);
+            return { flowGuid, defVersion: 3, nodes: [] };
+        },
+        ...over,
+    };
+}
+
+test("科室映射节点：读既有科室成员接口，启用成员进候选、停用成员标注不计入", async () => {
+    const api = stubApi();
+    const out = await resolveNodePreview(cfg(), depts, api);
+    assert.equal(out.ok, true);
+    assert.ok(out.headline.includes("校长室"));
+    assert.ok(out.headline.includes("2 名启用办理人"));
+    assert.deepEqual(api.calls.filter((c) => c.startsWith("deptMembers")), ["deptMembers:41"]);
+    assert.equal(out.rows.length, 3);
+    assert.deepEqual(out.rows.map((r) => r.userName), ["陈星", "刘文娟", "测试教师10"]);
+    assert.equal(out.rows[2].warn, "该成员已停用，不计入候选");
+    assert.ok(out.notes.some((n) => n.includes("预览只读")));
+});
+
+test("未选科室=明确的不可预览原因，而不是空列表里什么都不说", async () => {
+    const out = await resolveNodePreview(cfg({ deptKey: "" }), depts, stubApi());
+    assert.equal(out.ok, false);
+    assert.equal(out.blocked, "尚未选择科室映射，请先在「科室映射」里选一个科室。");
+});
+
+test("科室已被删除：点名到映射键并说明发布会被拦截", async () => {
+    const out = await resolveNodePreview(cfg({ deptKey: "99" }), depts, stubApi());
+    assert.equal(out.ok, false);
+    assert.ok(out.blocked?.includes("「99」"));
+    assert.ok(out.blocked?.includes("发布会被拦截"));
+});
+
+test("科室 0 名启用成员：给出补人路径，不误报成功", async () => {
+    const out = await resolveNodePreview(cfg({ deptKey: "42" }), depts, stubApi());
+    assert.equal(out.ok, false);
+    assert.ok(out.blocked?.includes("0 名启用办理人"));
+    assert.ok(out.blocked?.includes("办理人映射"));
+});
+
+test("指定用户节点：逐个走 UserBase 检索，禁用账号标注服务端会拒绝", async () => {
+    const api = stubApi();
+    const out = await resolveNodePreview(
+        cfg({ type: "USERS", deptKey: "", userIds: [101, 102, 999] }),
+        depts,
+        api,
+    );
+    assert.equal(out.ok, true);
+    assert.deepEqual(out.rows.map((r) => r.userName), ["陈星", "用户102", "#999"]);
+    assert.ok(out.rows[1].warn?.includes("非启用"));
+    assert.ok(out.rows[2].warn?.includes("UserBase 查不到"));
+});
+
+test("指定用户检索失败（服务不可达）：原因可读，堆栈类原文不外泄", async () => {
+    const api = stubApi({
+        lookupUser: async () => {
+            throw new Error("java.lang.RuntimeException: connect timed out at com.yunhai.UserClient");
+        },
+    });
+    const out = await resolveNodePreview(cfg({ type: "USERS", deptKey: "", userIds: [101] }), depts, api);
+    assert.equal(out.ok, false);
+    assert.ok(out.blocked?.includes("发布会被拦截"));
+    assert.ok(!out.rows[0].warn?.includes("java."));
+    assert.ok(out.rows[0].warn?.includes("服务未能处理本次请求"));
+});
+
+test("新建未保存线：已发布版本对账说明「尚未保存」，不假装有一版可比", async () => {
+    const out = await resolveNodePreview(cfg(), depts, stubApi(), "");
+    assert.equal(out.published?.state, "unavailable");
+    assert.ok(out.published?.text.includes("尚未保存"));
+});
+
+test("草稿节点不在已发布预览中：区分「未开启指派」与「尚未发布」", async () => {
+    const out = await resolveNodePreview(cfg(), depts, stubApi(), "g1");
+    assert.equal(out.published?.state, "missing");
+    assert.ok(out.published?.text.includes("v3"));
+    assert.ok(out.published?.text.includes("未开启发起时指派"));
+});
+
+test("已发布版本有本节点：候选人按服务端解析结果展示（含提单人剔除后的集）", async () => {
+    const api = stubApi({
+        applyPreview: async () => ({
+            defVersion: 4,
+            nodes: [{ nodeId: "u3", nodeName: "科室审核", candidates: [{ userId: 102, userName: "刘文娟" }] }],
+        }),
+    });
+    const out = await resolveNodePreview(cfg(), depts, api, "g1");
+    assert.equal(out.published?.state, "ok");
+    assert.equal(out.published?.defVersion, 4);
+    assert.deepEqual(out.published?.rows.map((r) => r.userName), ["刘文娟"]);
+});
+
+test("已发布预览被服务端拒绝（如流程线已停发）：把拒绝原因原样讲清，不静默", async () => {
+    const api = stubApi({
+        applyPreview: async () => {
+            throw new Error("流程线已停发，不可发起新办件");
+        },
+    });
+    const out = await resolveNodePreview(cfg(), depts, api, "g1");
+    assert.equal(out.published?.state, "unavailable");
+    assert.ok(out.published?.text.includes("流程线已停发，不可发起新办件"));
+});
+
+test("会签/发起时指派口径进说明文案（分层后信息不丢）", async () => {
+    const out = await resolveNodePreview(
+        cfg({ countersign: "ALL", assignPolicy: { mode: "SINGLE", required: true } }),
+        depts,
+        stubApi(),
+    );
+    assert.ok(out.notes.some((n) => n.includes("会签（全部同意才通过）")));
+    assert.ok(out.notes.some((n) => n.includes("单选 1 人") && n.includes("必选")));
+});
diff --git a/tests/components/approval-drawer.component.test.ts b/tests/components/approval-drawer.component.test.ts
new file mode 100644
index 0000000..8c802d1
--- /dev/null
+++ b/tests/components/approval-drawer.component.test.ts
@@ -0,0 +1,231 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mount, flushPromises, enableAutoUnmount, type VueWrapper } from "@vue/test-utils";
+import ViewUIPlus from "view-ui-plus";
+import { nextTick, reactive } from "vue";
+
+const { flowApiMock } = vi.hoisted(() => ({
+    flowApiMock: {
+        adminTeacherTree: vi.fn(),
+        deptMembers: vi.fn(),
+        mapLookupUser: vi.fn(),
+        applyPreview: vi.fn(),
+    },
+}));
+
+vi.mock("@/api/module/flow", () => ({ flowApi: flowApiMock }));
+
+import ApprovalDrawer from "@/views/flow/admin/def-editor/components/ApprovalDrawer.vue";
+import AssigneePreviewModal from "@/views/flow/admin/def-editor/components/AssigneePreviewModal.vue";
+import { EDITOR_CTX, createApproval, type ApprovalNode, type EditorItem } from "@/views/flow/admin/def-editor/model";
+
+/**
+ * 审批节点抽屉的组件测试：验收 P2-1 的两条硬指标——
+ * ① 面板里有可发现的「预览候选人」入口，点开是真接口解析结果；
+ * ② 核心/高级分层只挪展示，不改字段与数据语义。
+ * 注：iView Drawer/Modal 内容 teleport 到 body，一律按真实 DOM 断言。
+ */
+
+enableAutoUnmount(afterEach);
+
+function ok<T>(value: T) {
+    return { send: async () => value };
+}
+
+function makeNode(over: Partial<ApprovalNode> = {}): ApprovalNode {
+    return { ...createApproval("科室审核", { type: "DEPT_KEY", deptKey: "41" }), ...over } as ApprovalNode;
+}
+
+function baseCtx(over: Record<string, unknown> = {}) {
+    const model = reactive({
+        code: "c",
+        name: "n",
+        list: [] as EditorItem[],
+        settings: { rejectPolicy: "END_REJECTED", urge: { enabled: true, intervalHours: 24, maxTimes: 3 } },
+    });
+    return {
+        model,
+        depts: [
+            { deptKey: "41", deptName: "校长室", count: 2 },
+            { deptKey: "42", deptName: "空科室", count: 0 },
+        ],
+        userNames: { 101: "陈星", 102: "刘文娟" },
+        routers: [],
+        availableVars: [],
+        issueOf: () => [],
+        openNode: () => undefined,
+        removeNode: () => undefined,
+        insertItem: () => undefined,
+        addBranch: () => undefined,
+        removeBranch: () => undefined,
+        exitOutlets: () => undefined,
+        flowGuid: "g-line-1",
+        ...over,
+    };
+}
+
+function mountDrawer(node: ApprovalNode, ctxOver: Record<string, unknown> = {}): VueWrapper {
+    return mount(ApprovalDrawer, {
+        props: { modelValue: true, node },
+        global: {
+            plugins: [ViewUIPlus],
+            provide: { [EDITOR_CTX as unknown as symbol]: baseCtx(ctxOver) },
+        },
+        attachTo: document.body,
+    });
+}
+
+const bodyText = () => document.body.textContent || "";
+const q = (sel: string) => document.querySelector(sel) as HTMLElement | null;
+const hiddenByStyle = (el: HTMLElement | null) => (el?.getAttribute("style") || "").includes("display: none");
+
+async function clickEl(el: HTMLElement | null) {
+    expect(el, "目标元素不存在").toBeTruthy();
+    el!.click();
+    await nextTick();
+    await flushPromises();
+}
+
+function buttonNamed(text: string) {
+    return (Array.from(document.querySelectorAll("button")) as HTMLButtonElement[])
+        .find((b) => (b.textContent || "").includes(text)) || null;
+}
+
+beforeEach(() => {
+    document.body.innerHTML = "";
+    flowApiMock.adminTeacherTree.mockImplementation(() => ok([]));
+    flowApiMock.deptMembers.mockImplementation((deptId: string) =>
+        ok(deptId === "41"
+            ? [
+                { userId: 101, userName: "陈星", status: 0 },
+                { userId: 102, userName: "刘文娟", status: 0 },
+                { userId: 103, userName: "测试教师10", status: 1 },
+            ]
+            : []),
+    );
+    flowApiMock.mapLookupUser.mockImplementation((id: number) => ok({ id, name: `用户${id}`, status: 1 }));
+    flowApiMock.applyPreview.mockImplementation(() => ok({ defVersion: 3, nodes: [] }));
+});
+
+afterEach(() => {
+    vi.clearAllMocks();
+});
+
+describe("审批节点抽屉 · 核心/高级分层", () => {
+    it("核心区直接可见：节点名称、审批人、预览入口；高级项默认收起", async () => {
+        mountDrawer(makeNode());
+        await flushPromises();
+        const text = bodyText();
+        expect(text).toContain("节点名称");
+        expect(text).toContain("审批人类型");
+        expect(text).toContain("科室映射");
+        expect(text).toContain("预览候选人");
+        expect(text).toContain("高级设置");
+        // 收起只是隐藏，不删除能力
+        expect(hiddenByStyle(q(".adv-body"))).toBe(true);
+    });
+
+    it("高级能力一个都没少：展开后会签/发起时指派/时限/多出口都在原位置", async () => {
+        mountDrawer(makeNode());
+        await flushPromises();
+        await clickEl(q(".adv-head"));
+        const adv = q(".adv-body");
+        expect(hiddenByStyle(adv)).toBe(false);
+        const text = adv?.textContent || "";
+        expect(text).toContain("多人审批方式");
+        expect(text).toContain("发起时指派");
+        expect(text).toContain("办理时限（小时）");
+        expect(text).toContain("出口路由");
+    });
+
+    it("已配置高级项的节点：打开抽屉自动展开，收起态也标出配了哪几项", async () => {
+        mountDrawer(makeNode({ countersign: "ALL", deadlineHours: 24 }));
+        await flushPromises();
+        expect(hiddenByStyle(q(".adv-body"))).toBe(false);
+
+        await clickEl(q(".adv-head"));
+        expect(q(".adv-badge")?.textContent).toContain("会签");
+        expect(q(".adv-badge")?.textContent).toContain("办理时限");
+    });
+
+    it("分层不改数据：折叠/展开来回，节点字段值不变", async () => {
+        const node = makeNode({ countersign: "ALL", deadlineHours: 8, outlets: ["同意", "退回"] });
+        const snapshot = JSON.stringify(node);
+        mountDrawer(node);
+        await flushPromises();
+        await clickEl(q(".adv-head"));
+        await clickEl(q(".adv-head"));
+        expect(JSON.stringify(node)).toEqual(snapshot);
+    });
+});
+
+describe("审批节点抽屉 · 预览候选人入口", () => {
+    async function openPreview() {
+        await clickEl(buttonNamed("预览候选人"));
+    }
+
+    it("点入口即按当前节点配置走真实接口（科室成员 + 发起预览），不是静态示例", async () => {
+        mountDrawer(makeNode());
+        await flushPromises();
+        await openPreview();
+        expect(flowApiMock.deptMembers).toHaveBeenCalledWith("41");
+        expect(flowApiMock.applyPreview).toHaveBeenCalledWith("g-line-1");
+        const text = bodyText();
+        expect(text).toContain("校长室");
+        expect(text).toContain("陈星");
+        expect(text).toContain("刘文娟");
+        expect(text).toContain("该成员已停用，不计入候选");
+        expect(text).toContain("预览只读");
+    });
+
+    it("预览读的是抽屉里的未保存改动（换科室后立刻按新科室解析）", async () => {
+        mountDrawer(makeNode({ assignee: { type: "DEPT_KEY", deptKey: "42" } }));
+        await flushPromises();
+        await openPreview();
+        expect(flowApiMock.deptMembers).toHaveBeenCalledWith("42");
+        const text = bodyText();
+        expect(text).toContain("0 名启用办理人");
+        expect(text).toContain("发布会被拦截");
+    });
+
+    it("指定用户节点按 UserBase 检索解析，非启用账号如实标注", async () => {
+        flowApiMock.mapLookupUser.mockImplementation((id: number) =>
+            ok(id === 101 ? { id: 101, name: "陈星", status: 1 } : { id, name: `用户${id}`, status: 0 }),
+        );
+        mountDrawer(makeNode({ assignee: { type: "USERS", userIds: [101, 102] } }));
+        await flushPromises();
+        await openPreview();
+        expect(flowApiMock.mapLookupUser).toHaveBeenCalledWith(101);
+        expect(flowApiMock.mapLookupUser).toHaveBeenCalledWith(102);
+        const text = bodyText();
+        expect(text).toContain("陈星");
+        expect(text).toContain("非启用");
+    });
+
+    it("流程线尚未保存时说明没有可比对的已发布版本，不假装有一版", async () => {
+        mountDrawer(makeNode(), { flowGuid: "" });
+        await flushPromises();
+        await openPreview();
+        expect(flowApiMock.applyPreview).not.toHaveBeenCalled();
+        expect(bodyText()).toContain("尚未保存");
+    });
+
+    it("预览只读：打开再关闭不写回节点、不产生任何接口写入", async () => {
+        const node = makeNode();
+        const before = JSON.stringify(node);
+        const wrapper = mountDrawer(node);
+        await flushPromises();
+        await openPreview();
+        await clickEl(buttonNamed("关闭"));
+        expect(JSON.stringify(node)).toEqual(before);
+        expect(wrapper.emitted("update:modelValue")).toBeUndefined();
+        // 预览的数据源只有读接口：科室成员 / 用户检索 / 发起预览
+        expect(flowApiMock.deptMembers).toHaveBeenCalled();
+        expect(flowApiMock.applyPreview).toHaveBeenCalled();
+    });
+
+    it("预览弹窗组件确实挂在抽屉内（入口不是死链）", async () => {
+        const wrapper = mountDrawer(makeNode());
+        await flushPromises();
+        expect(wrapper.findComponent(AssigneePreviewModal).exists()).toBe(true);
+    });
+});
diff --git a/tests/components/assign-embed.component.test.ts b/tests/components/assign-embed.component.test.ts
new file mode 100644
index 0000000..07655cc
--- /dev/null
+++ b/tests/components/assign-embed.component.test.ts
@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mount, flushPromises, enableAutoUnmount, type VueWrapper } from "@vue/test-utils";
+import ViewUIPlus from "view-ui-plus";
+import { nextTick } from "vue";
+
+import FlowAssignEmbed from "@/components/FlowAssignEmbed.vue";
+
+/**
+ * FL 侧选人 iframe 宿主的协议测试（自动化测试宿主，不是产品入口）。
+ * 覆盖：地址构造（单 hash）、四道校验、监听器生命周期、取消保留旧选择、确认后 B 替换 A。
+ */
+
+enableAutoUnmount(afterEach);
+
+const PROTO = "flow";
+const VERSION = 1;
+const APP_ORIGIN = window.location.origin;
+
+function baseData(over: Record<string, unknown> = {}) {
+    return {
+        proto: PROTO,
+        v: VERSION,
+        type: "assign-confirmed",
+        contextId: "",
+        flowGuid: "g-embed",
+        defVersion: 3,
+        assigns: [{ nodeId: "u2", userIds: [101] }],
+        ...over,
+    };
+}
+
+/** view-ui-plus Modal 默认把内容 teleport 到 body，组件子树里查不到——按真实 DOM 取 */
+function frameEl(): HTMLIFrameElement | null {
+    return document.querySelector("iframe") as HTMLIFrameElement | null;
+}
+
+/** 父页收到消息的唯一入口：直接派发 MessageEvent，绕开真实 iframe 加载 */
+function post(wrapper: VueWrapper, data: unknown, opts: { origin?: string; source?: unknown } = {}) {
+    const frame = frameEl() as HTMLIFrameElement;
+    const ev = new MessageEvent("message", {
+        origin: opts.origin ?? APP_ORIGIN,
+        source: (opts.source ?? frame.contentWindow) as Window | null,
+        data,
+    });
+    window.dispatchEvent(ev);
+    return nextTick();
+}
+
+function mountHost(props: Record<string, unknown> = {}) {
+    return mount(FlowAssignEmbed, {
+        props: { flowGuid: "g-embed", ...props },
+        global: { plugins: [ViewUIPlus] },
+        attachTo: document.body,
+    });
+}
+
+/** 开框后 jsdom 仍不会真正加载子文档：给 iframe 挂一个显式窗口桩，父侧按它核 event.source */
+async function openHost(wrapper: VueWrapper) {
+    (wrapper.vm as any).open();
+    await nextTick();
+    await flushPromises();
+    const frame = frameEl() as HTMLIFrameElement;
+    Object.defineProperty(frame, "contentWindow", { value: { __frame: true }, configurable: true });
+}
+
+beforeEach(() => {
+    document.body.innerHTML = "";
+});
+
+describe("FlowAssignEmbed 地址与会话", () => {
+    it("open 生成单 hash 的 iframe 地址，带 flowGuid 与本次 contextId", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const src = (frameEl() as HTMLIFrameElement).getAttribute("src") || "";
+        expect(src.split("#").length - 1).toBe(1);
+        expect(src).toContain(`${APP_ORIGIN}/#/assign-preview?`);
+        expect(src).toContain("flowGuid=g-embed");
+        expect(src).toContain("contextId=");
+        expect((wrapper.vm as any).contextId).toBeTruthy();
+    });
+
+    it("缺少 flowGuid 时不开框、不监听", async () => {
+        const addSpy = vi.spyOn(window, "addEventListener");
+        const wrapper = mountHost({ flowGuid: "" });
+        (wrapper.vm as any).open();
+        await nextTick();
+        expect(frameEl()).toBeNull();
+        expect(addSpy.mock.calls.filter((c) => c[0] === "message").length).toBe(0);
+        addSpy.mockRestore();
+    });
+});
+
+describe("FlowAssignEmbed 消息校验", () => {
+    it("协议相符的确认消息：回传最终选择与版本锚", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        await post(wrapper, baseData({ contextId: cid }));
+        const events = wrapper.emitted("confirmed");
+        expect(events).toHaveLength(1);
+        expect((events[0][0] as any).assigns).toEqual([{ nodeId: "u2", userIds: [101] }]);
+        expect((events[0][0] as any).defVersion).toBe(3);
+        expect((events[0][0] as any).flowGuid).toBe("g-embed");
+    });
+
+    it("异源、异窗口、异 contextId、畸形信封一律丢弃，不影响宿主", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        const fakeOtherWindow = { __other: true };
+
+        await post(wrapper, baseData({ contextId: cid }), { origin: "https://evil.example.com" });
+        await post(wrapper, baseData({ contextId: cid }), { source: fakeOtherWindow });
+        await post(wrapper, baseData({ contextId: "stale-from-prev-session" }));
+        await post(wrapper, { proto: "fc", v: VERSION, type: "assign-confirmed", contextId: cid });
+        await post(wrapper, { proto: PROTO, v: 99, type: "assign-confirmed", contextId: cid });
+        await post(wrapper, { proto: PROTO, v: VERSION, type: "not-ours", contextId: cid });
+        await post(wrapper, "plain-string-from-page-script");
+
+        expect(wrapper.emitted("confirmed")).toBeUndefined();
+        expect(wrapper.emitted("cancelled")).toBeUndefined();
+    });
+
+    it("确认消息缺 assigns 时形状校验拦下（不落成空选择）", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        await post(wrapper, baseData({ contextId: cid, assigns: undefined }));
+        expect(wrapper.emitted("confirmed")).toBeUndefined();
+    });
+});
+
+describe("FlowAssignEmbed 生命周期与选择语义", () => {
+    it("取消：只通知宿主，不产生确认，旧选择不被覆盖", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        await post(wrapper, baseData({ contextId: cid, type: "assign-cancelled" }));
+        expect(wrapper.emitted("cancelled")).toHaveLength(1);
+        expect(wrapper.emitted("confirmed")).toBeUndefined();
+    });
+
+    it("确认后同一会话的迟到消息不再触发（监听器已摘）", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        await post(wrapper, baseData({ contextId: cid }));
+        await post(wrapper, baseData({ contextId: cid, assigns: [{ nodeId: "u2", userIds: [777] }] }));
+        const events = wrapper.emitted("confirmed");
+        expect(events).toHaveLength(1);
+        expect((events[0][0] as any).assigns[0].userIds).toEqual([101]);
+    });
+
+    it("宿主自己关框（未答复）：按取消处理并摘监听", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        (wrapper.vm as any).close();
+        await nextTick();
+        expect(wrapper.emitted("cancelled")).toHaveLength(1);
+        await post(wrapper, baseData({ contextId: cid }));
+        expect(wrapper.emitted("confirmed")).toBeUndefined();
+    });
+
+    it("重开换新 contextId：旧会话残消息不影响新一轮，确认以最近一次为准（B 替换 A）", async () => {
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid1 = (wrapper.vm as any).contextId;
+        await post(wrapper, baseData({ contextId: cid1, assigns: [{ nodeId: "u2", userIds: [101] }] }));
+        expect((wrapper.emitted("confirmed")![0][0] as any).assigns[0].userIds).toEqual([101]);
+
+        // 宿主把 A 记在内存里，重开选 B
+        await openHost(wrapper);
+        const cid2 = (wrapper.vm as any).contextId;
+        expect(cid2).not.toEqual(cid1);
+
+        // 上一轮残帧补发一条：按 context 失效
+        await post(wrapper, baseData({ contextId: cid1, assigns: [{ nodeId: "u2", userIds: [999] }] }));
+        expect(wrapper.emitted("confirmed")).toHaveLength(1);
+
+        await post(wrapper, baseData({ contextId: cid2, assigns: [{ nodeId: "u2", userIds: [102, 103] }] }));
+        const events = wrapper.emitted("confirmed");
+        expect(events).toHaveLength(2);
+        expect((events[1][0] as any).assigns[0].userIds).toEqual([102, 103]);
+    });
+
+    it("卸载后监听器摘掉，后续消息不再回传", async () => {
+        const removeSpy = vi.spyOn(window, "removeEventListener");
+        const wrapper = mountHost();
+        await openHost(wrapper);
+        const cid = (wrapper.vm as any).contextId;
+        const frame = frameEl() as HTMLIFrameElement;
+        wrapper.unmount();
+        expect(removeSpy.mock.calls.filter((c) => c[0] === "message").length).toBeGreaterThan(0);
+        window.dispatchEvent(new MessageEvent("message", {
+            origin: APP_ORIGIN,
+            source: frame.contentWindow as Window,
+            data: baseData({ contextId: cid }),
+        }));
+        await flushPromises();
+        expect(wrapper.emitted("confirmed")).toBeUndefined();
+        removeSpy.mockRestore();
+    });
+});
diff --git a/tests/components/defs-line-offline.component.test.ts b/tests/components/defs-line-offline.component.test.ts
index 4a0889d..225d3bb 100644
--- a/tests/components/defs-line-offline.component.test.ts
+++ b/tests/components/defs-line-offline.component.test.ts
@@ -205,7 +205,7 @@ describe("Defs 流程线停发/恢复交互", () => {
 
         expect(wrapper.text()).toContain("处理中…");
         expect(lineLink(wrapper, "正常线", "停发流程线")!.classes()).toContain("disabled");
-        expect(flowApiMock.defOfflineLine).toHaveBeenCalledWith("g-normal");
+        expect(flowApiMock.defOfflineLine).toHaveBeenCalledWith("g-normal", { silentBizToast: true });
 
         gate.resolve(2);
         await pending;
@@ -265,7 +265,7 @@ describe("Defs 流程线停发/恢复交互", () => {
         await pending;
         await flushPromises();
 
-        expect(flowApiMock.defEnableLine).toHaveBeenCalledWith("g-off");
+        expect(flowApiMock.defEnableLine).toHaveBeenCalledWith("g-off", { silentBizToast: true });
         expect(flowApiMock.defOfflineLine).not.toHaveBeenCalled();
         expect(successSpy).toHaveBeenCalledWith(expect.stringContaining("流程线已恢复（1 个版本"));
         expect(flowApiMock.defList).toHaveBeenCalledTimes(2);
diff --git a/tests/convert-roundtrip.test.ts b/tests/convert-roundtrip.test.ts
new file mode 100644
index 0000000..8d857fd
--- /dev/null
+++ b/tests/convert-roundtrip.test.ts
@@ -0,0 +1,145 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { toContentJson, fromContentJson } from "../src/views/flow/admin/def-editor/convert";
+import { createApproval, createCondition, createNotify, createParallel } from "../src/views/flow/admin/def-editor/model";
+import type { EditorItem, EditorModel } from "../src/views/flow/admin/def-editor/model";
+
+/**
+ * 流程定义序列化回归闸门（任务书 §6.8「检查流程定义序列化」）。
+ * 本轮只动编辑器面板的**展示分层**，这里钉住：结构语义不因这些改动漂移。
+ * 对比口径按语义集合比（节点字段集 + 边三元组集），不比数组顺序——空泳道会产生纯顺序差。
+ */
+
+type Json = ReturnType<typeof toContentJson>;
+
+function model(items: EditorItem[]): EditorModel {
+    return {
+        code: "rt-demo",
+        name: "往返回归",
+        list: items,
+        settings: { rejectPolicy: "END_REJECTED", urge: { enabled: true, intervalHours: 24, maxTimes: 3 } },
+    };
+}
+
+const clone = (o: unknown) => JSON.parse(JSON.stringify(o));
+
+function fullItems(): EditorItem[] {
+    const approval = createApproval("科室审核", { type: "DEPT_KEY", deptKey: "41" });
+    approval.countersign = "ALL";
+    approval.deadlineHours = 8;
+    approval.assignPolicy = { mode: "SINGLE", required: true };
+
+    const outletNode = createApproval("多出口", { type: "USERS", userIds: [101, 102] });
+    outletNode.outlets = ["同意", "退回", "加签"];
+    outletNode.branches = [[createApproval("分支一")], [], [createNotify("分支三抄送")]];
+
+    const cond = createCondition();
+    cond.judgeMode = "EXPRESSION";
+    cond.outlets = ["大额", "小额"];
+    cond.conditions = ["amount > 1000", ""];
+    cond.branches = [[createApproval("大额复核")], [createApproval("小额直过")]];
+
+    const par = createParallel();
+    par.branches = [[createNotify("并行抄送A")], [createApproval("并行复核B", { type: "DEPT_KEY", deptKey: "42" })]];
+
+    return [approval, cond, par, outletNode];
+}
+
+/** 已知缺陷用：非首位并行容器重解析后 split/join 会换成新 id（见最后一条用例） */
+function parallelDerivedIds(json: Json): string[] {
+    return json.nodes.filter((n) => n.type === "PARALLEL_SPLIT" || n.type === "PARALLEL_JOIN").map((n) => n.id);
+}
+
+function roundTrip(times: number, json: Json): Json {
+    let cur = json;
+    for (let i = 0; i < times; i++) {
+        cur = toContentJson({ ...model([]), ...fromContentJson(clone(cur)) } as EditorModel);
+    }
+    return cur;
+}
+
+test("结构往返两轮：每个节点的配置语义逐项一致（并行派生 id 另用例专门记录）", () => {
+    const first = toContentJson(model(fullItems()));
+    const second = roundTrip(1, first);
+    const third = roundTrip(2, first);
+
+    const byId = (json: Json) => {
+        const m = new Map<string, string>();
+        json.nodes.forEach((n) => m.set(n.id, JSON.stringify(n)));
+        return m;
+    };
+    const a = byId(first);
+    const b = byId(second);
+    const c = byId(third);
+
+    // 配置类节点（审批/抄送/条件）的 id 与内容必须逐字不变
+    ["u1", "u2", "u3", "u4", "u5c", "u8", "u9", "start", "end"].forEach((id) => {
+        assert.equal(b.get(id), a.get(id), `节点 ${id} 内容在第二轮发生变化`);
+        assert.equal(c.get(id), a.get(id), `节点 ${id} 内容在第三轮发生变化`);
+    });
+    assert.deepEqual(second.settings, first.settings);
+    assert.deepEqual(third.settings, first.settings);
+
+    // 并行分支内的两名办理人同样不变
+    const branchIds = ["u13", "u14"];
+    branchIds.forEach((id) => assert.equal(b.get(id), a.get(id), `并行分支节点 ${id} 变化`));
+
+    // 出口边（含条件表达式）在两轮都存在
+    const edgeSet = (json: Json) => new Set(json.edges.map((e) => `${e.from}->${e.to}${e.name ? `(${e.name})` : ""}${e.condition ? `[${e.condition}]` : ""}`));
+    const ea = edgeSet(first);
+    const eb = edgeSet(second);
+    ["u2->u3(同意)", "u2->u4(加签)", "u2->end(退回)", "u5c->u8(大额)[amount > 1000]", "u5c->u9(小额)"].forEach((e) => {
+        assert.ok(ea.has(e), `第一轮缺少边 ${e}`);
+        assert.ok(eb.has(e), `第二轮缺少边 ${e}`);
+    });
+});
+
+test("关键语义字段全部活过往返，不被展示层分层影响", () => {
+    const first = toContentJson(model(fullItems()));
+    const parsed = fromContentJson(clone(first));
+    const second = toContentJson({ ...model([]), ...parsed } as EditorModel);
+
+    // 会签 ALL 是后端缺省值，生成 JSON 时按设计省略（model.ts 注释）；口径以解析回编辑态为准
+    const approvalItem = parsed.list.find((it) => it.kind === "approval" && it.assignee?.type === "DEPT_KEY");
+    assert.ok(approvalItem && approvalItem.kind === "approval");
+    assert.equal(approvalItem.countersign, "ALL", "会签语义在解析端丢失");
+    assert.equal(approvalItem.deadlineHours, 8, "办理时限丢失");
+    assert.deepEqual(approvalItem.assignPolicy, { mode: "SINGLE", required: true }, "发起时指派策略丢失");
+
+    assert.ok(second.nodes.some((n) => n.type === "NOTIFY" && n.receivers?.type === "USERS"), "抄送对象丢失");
+    assert.ok(second.nodes.some((n) => n.judgeMode === "EXPRESSION"), "条件判断方式丢失");
+    assert.ok(second.nodes.some((n) => n.type === "PARALLEL_SPLIT"), "并行拆分丢失");
+    assert.ok(second.nodes.some((n) => n.type === "PARALLEL_JOIN" && n.waitFor === "ALL"), "并行汇聚语义丢失");
+    assert.ok(second.nodes.some((n) => n.id === "start") && second.nodes.some((n) => n.id === "end"), "端点丢失");
+    assert.ok(second.edges.filter((e) => e.name).length >= 3, "多出口/条件分支的出口名丢失");
+});
+
+test("设置与端点名不被丢：rejectPolicy/urge/start-end name 原样回写", () => {
+    const m = model([createApproval("单节点")]);
+    m.startName = "提交申请";
+    m.endName = "办结";
+    const json = toContentJson(m);
+    assert.equal(json.settings.rejectPolicy, "END_REJECTED");
+    assert.equal(json.settings.urge.intervalHours, 24);
+    assert.equal((json.nodes.find((n) => n.type === "START") || {}).name, "提交申请");
+    assert.equal((json.nodes.find((n) => n.type === "END") || {}).name, "办结");
+});
+
+test("已知缺陷（本轮不修，修它等于改序列化契约）：并行容器重解析后 split/join 换成新 id", () => {
+    const first = toContentJson(model([createApproval("a"), createParallel()]));
+    const before = parallelDerivedIds(first);
+    const rt = roundTrip(1, first);
+    const after = parallelDerivedIds(rt);
+
+    assert.equal(after.length, before.length, "并行拆/合节点数量发生变化");
+    assert.notDeepEqual(after, before, "并行 id 改名行为已变化——若已被修好，请把本用例改成断言 id 稳定并同步终审");
+
+    // 改名只涉及 id 字面，汇聚语义不变
+    const join = rt.nodes.find((n) => n.type === "PARALLEL_JOIN");
+    assert.equal(rt.nodes.filter((n) => n.type === "PARALLEL_SPLIT").length, 1);
+    assert.equal(join?.waitFor, "ALL", "并行汇聚 waitFor 语义丢失");
+    // 拆分/汇聚与分支节点的连接关系仍然闭合（每个分支节点都连到某条 split/join）
+    const anchors = new Set(after);
+    const linked = rt.edges.filter((e) => anchors.has(e.from) || anchors.has(e.to));
+    assert.ok(linked.length >= 4, `并行连线丢失，只剩 ${linked.length} 条`);
+});
diff --git a/tests/flow-error.test.ts b/tests/flow-error.test.ts
new file mode 100644
index 0000000..b36daff
--- /dev/null
+++ b/tests/flow-error.test.ts
@@ -0,0 +1,55 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { describeFlowError, flowFailTip, FLOW_GENERIC_FALLBACK, FLOW_NETWORK_FALLBACK } from "../src/utils/flowError";
+
+/** 审批失败文案单测：口径=具体业务话原样透出，通用/异常形态换兜底话术且不外泄内部信息 */
+
+test("后端给出通用 code=6 占位文案：换成不误导的兜底话术，不猜原因", () => {
+    assert.equal(describeFlowError("内部服务错误"), FLOW_GENERIC_FALLBACK);
+    assert.equal(describeFlowError("内部服务错误！"), FLOW_GENERIC_FALLBACK);
+    assert.equal(describeFlowError("业务错误"), FLOW_GENERIC_FALLBACK);
+    assert.equal(describeFlowError(""), FLOW_GENERIC_FALLBACK);
+    assert.ok(!FLOW_GENERIC_FALLBACK.includes("成功"));
+});
+
+test("契约内的具体业务 msg 原样透出，不改写不误导", () => {
+    assert.equal(describeFlowError("流程线不存在：8d07f049"), "流程线不存在：8d07f049");
+    assert.equal(describeFlowError("该任务已被他人办理"), "该任务已被他人办理");
+    assert.equal(
+        describeFlowError("该待办缺少流程推进记录，需管理员回填后办理"),
+        "该待办缺少流程推进记录，需管理员回填后办理",
+    );
+});
+
+test("异常/SQL/令牌形态不回显：堆栈与凭据不进页面", () => {
+    const leaks = [
+        "java.lang.IllegalStateException: D09 task has no proven activation; audited backfill required",
+        "at com.yunhai.flowcenter.service.FlowTaskService.handle(FlowTaskService.java:100)",
+        "Caused by: SQLException error code [1064]",
+        "refresh token=Bearer abcdef123456",
+        "<html><body>500 Internal Server Error</body></html>",
+    ];
+    for (const raw of leaks) {
+        const out = describeFlowError(raw);
+        assert.equal(out, FLOW_GENERIC_FALLBACK, raw);
+        assert.ok(!/java\.|Exception|SQL|Bearer|<html>/i.test(out));
+    }
+});
+
+test("网络/登录态失败：按网络口径提示，不与业务失败混说", () => {
+    assert.equal(describeFlowError("网络错误"), FLOW_NETWORK_FALLBACK);
+    assert.equal(describeFlowError("Failed to fetch"), FLOW_NETWORK_FALLBACK);
+    assert.equal(describeFlowError("timeout of 20000ms exceeded"), FLOW_NETWORK_FALLBACK);
+});
+
+test("Error 对象可直接传入（取 message）", () => {
+    assert.equal(describeFlowError(new Error("流程线不存在：g1")), "流程线不存在：g1");
+    assert.equal(describeFlowError(new Error("内部服务错误")), FLOW_GENERIC_FALLBACK);
+});
+
+test("页面内联提示带动作名，明确「未生效」而不是成功", () => {
+    const tip = flowFailTip("同意", new Error("内部服务错误"));
+    assert.ok(tip.startsWith("同意未完成："));
+    assert.ok(tip.includes(FLOW_GENERIC_FALLBACK));
+    assert.ok(!tip.includes("已同意"));
+});
diff --git a/tests/line-offline.test.ts b/tests/line-offline.test.ts
index b1f764c..f967f1f 100644
--- a/tests/line-offline.test.ts
+++ b/tests/line-offline.test.ts
@@ -142,6 +142,16 @@ test("静态接线：Defs.vue 使用线级接口，不混入 listAll 或重复
 
 test("静态接线：API 客户端使用既有 admin 端点与 flowGuid 请求体", () => {
     const api = readFileSync(resolve(process.cwd(), "src/api/module/flow.ts"), "utf8");
-    assert.match(api, /`\$\{ROOT\}\/admin\/def\/offlineLine`, \{ flowGuid \}/);
-    assert.match(api, /`\$\{ROOT\}\/admin\/def\/enableLine`, \{ flowGuid \}/);
+    assert.match(api, /`\$\{ROOT\}\/admin\/def\/offlineLine`, \{ flowGuid \}, config/);
+    assert.match(api, /`\$\{ROOT\}\/admin\/def\/enableLine`, \{ flowGuid \}, config/);
+});
+
+test("静态接线：线级启停失败只有一条错误面（调用方带 silentBizToast，全局 toast 认这个旗标）", () => {
+    const defs = readFileSync(resolve(process.cwd(), "src/views/flow/admin/Defs.vue"), "utf8");
+    const core = readFileSync(resolve(process.cwd(), "src/utils/alova/alova-core.ts"), "utf8");
+    assert.match(defs, /defOfflineLine\(guid, \{ silentBizToast: true \}\)/);
+    assert.match(defs, /defEnableLine\(guid, \{ silentBizToast: true \}\)/);
+    assert.match(core, /silentBizToast/);
+    assert.match(core, /if \(!isSilentBizToast\(method\)\) onBizError/);
+    assert.match(core, /if \(!isSilentBizToast\(method\)\) onHttpError/);
 });