weaver-work-cli 0.1.40 → 0.1.44

package/dist/shortcuts/ehr/operations/recruit-candidate-import.js

@@ -1,3 +1,4 @@
+import { CONTINUATION_TTL_MS, CONTINUATION_TTL_SECONDS } from '../../../core/continuation-ttl.js';
 import { createHash } from 'node:crypto';
 import { readFile, stat } from 'node:fs/promises';
 import { basename } from 'node:path';
@@ -100,6 +101,133 @@ function joinRange(start, end) {
         return undefined;
     return `${s},${e}`;
 }
+// ── 日期格式预检与归一（2026-11-05 与 recruit-stage 同步修复）──
+// 人才表单接口只接受 yyyy-MM-dd。模型常给「2020.11」「2008-08」「2004.09-2008.07」，
+// 会让 dataset 新增整批校验失败 → 回退建主表 → 补明细又被同一格式拦下 → 明细全丢。
+// 规则同 recruit-stage：只有年月时开始补 -01、结束补当月最后一天；「至今」归一为空（不伪造结束日）；
+// 无法识别则跳过该字段并在 warnings 明示，绝不静默改写。
+const DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+const ONGOING_RE = /至今|现在|今|now|present/i;
+const RE_RANGE_FULL = /^\s*(\d{4}[.\-/年]\d{1,2}[.\-/月]\d{1,2}\s*日?)\s*[-–—~至,，]\s*(\d{4}[.\-/年]\d{1,2}[.\-/月]\d{1,2}\s*日?|至今|现在|今)\s*$/;
+const RE_RANGE_YM = /^\s*(\d{4}[.\-/年]\d{1,2})\s*[-–—~至,，]\s*(\d{4}[.\-/年]\d{1,2}|至今|现在|今)\s*$/;
+/** 单日期片段 → yyyy-MM-dd；isEnd=true 且缺日时补该月最后一天。无法解析返回 ''。 */
+function normDatePart(raw, isEnd) {
+    const s = String(raw ?? '').trim();
+    if (!s)
+        return '';
+    if (ONGOING_RE.test(s))
+        return '';
+    if (DATE_ONLY_RE.test(s))
+        return s;
+    const m = s.match(/^(\d{4})\s*[.\-/年]?\s*(\d{1,2})?\s*[.\-/月]?\s*(\d{1,2})?\s*日?$/);
+    if (!m)
+        return '';
+    const y = Number(m[1]);
+    const mo = m[2] ? Number(m[2]) : 1;
+    if (!y || mo < 1 || mo > 12)
+        return '';
+    const lastDay = new Date(y, mo, 0).getDate();
+    let d;
+    if (m[3]) {
+        d = Number(m[3]);
+        if (d < 1 || d > lastDay)
+            return '';
+    }
+    else {
+        d = isEnd ? lastDay : 1;
+    }
+    return `${y}-${String(mo).padStart(2, '0')}-${String(d).padStart(2, '0')}`;
+}
+/** 日期区间 → "start,end"；单值原样归一。 */
+function normDateRange(raw) {
+    const s = Array.isArray(raw)
+        ? raw.map((x) => String(x ?? '').trim()).filter(Boolean).join(',')
+        : String(raw ?? '').trim();
+    if (!s)
+        return '';
+    const m = s.match(RE_RANGE_FULL) || s.match(RE_RANGE_YM);
+    if (m) {
+        const a = normDatePart(m[1], false);
+        if (!a)
+            return '';
+        const b = normDatePart(m[2], true);
+        return b ? `${a},${b}` : a;
+    }
+    return normDatePart(s, false);
+}
+/**
+ * 就地归一简历入参里的全部日期字段，把每处改动写入 warnings（不静默改写）。
+ * 覆盖：joinworkdate / graduate_date / birthday；academicInformations[].study_date；
+ *       jobInformations|workExperiences|projectExperiences 的 start_date/end_date；
+ *       internshipExperiences[].entry_time；awardExperiences[].award_date。
+ */
+export function normalizeImportDates(input, warnings) {
+    if (!input || typeof input !== 'object')
+        return;
+    const one = (label, val, isEnd = false) => {
+        const before = String(val ?? '').trim();
+        if (!before)
+            return '';
+        if (ONGOING_RE.test(before))
+            return '';
+        const after = normDatePart(before, isEnd);
+        if (!after) {
+            warnings.push(`日期无法识别，已跳过该字段（避免接口整批校验失败）：${label} = 「${before}」`);
+            return '';
+        }
+        if (after !== before)
+            warnings.push(`日期已规范化：${label} 「${before}」→「${after}」`);
+        return after;
+    };
+    for (const k of ['joinworkdate', 'graduate_date', 'birthday']) {
+        if (input[k] === undefined || input[k] === null)
+            continue;
+        input[k] = one(k, input[k], false);
+    }
+    if (Array.isArray(input.academicInformations)) {
+        input.academicInformations.forEach((r, i) => {
+            if (!r || typeof r !== 'object' || r.study_date === undefined)
+                return;
+            const before = String(r.study_date ?? '').trim();
+            if (!before)
+                return;
+            const after = normDateRange(before);
+            if (!after) {
+                warnings.push(`日期区间无法识别，已跳过：academicInformations[${i}].study_date = 「${before}」`);
+                r.study_date = '';
+            }
+            else {
+                if (after !== before)
+                    warnings.push(`日期已规范化：academicInformations[${i}].study_date 「${before}」→「${after}」`);
+                r.study_date = after;
+            }
+        });
+    }
+    for (const key of ['jobInformations', 'workExperiences', 'projectExperiences']) {
+        const arr = input[key];
+        if (!Array.isArray(arr))
+            continue;
+        arr.forEach((r, i) => {
+            if (!r || typeof r !== 'object')
+                return;
+            if (r.start_date !== undefined && r.start_date !== null)
+                r.start_date = one(`${key}[${i}].start_date`, r.start_date, false);
+            if (r.end_date !== undefined && r.end_date !== null)
+                r.end_date = one(`${key}[${i}].end_date`, r.end_date, true);
+        });
+    }
+    for (const [key, field] of [['internshipExperiences', 'entry_time'], ['awardExperiences', 'award_date']]) {
+        const arr = input[key];
+        if (!Array.isArray(arr))
+            continue;
+        arr.forEach((r, i) => {
+            if (!r || typeof r !== 'object')
+                return;
+            if (r[field] !== undefined && r[field] !== null)
+                r[field] = one(`${key}[${i}].${field}`, r[field], false);
+        });
+    }
+}
 async function resolveSubTableMeta(env, formId) {
     let data = null;
     try {
@@ -335,45 +463,122 @@ async function uploadResumeFile(env, filePath, fieldId, formId) {
     }
     return { fileid: String(fileid), name, size };
 }
-/** 平台标签：按名称在本环境标签清单里解析 id（同名优先公共），不自动创建。 */
-async function applyPlatformTags(env, talentId, tagNames) {
-    if (!tagNames.length)
-        return { applied: [], skipped: [] };
-    const list = (await env.host.request({
+/** 按名查标签（并行 type=0 公共 / type=1 个人）。服务端若忽略 name 会返回满页 → filtered=false，由调用方回退全量。
+ *  🔴 2026-11-04 修：原实现只取第 1 页 500 条，环境标签超 500 时后续标签永远匹配不到（静默跳过）。 */
+async function queryTagByName(env, name) {
+    const pageSize = 100;
+    const bodyOf = (type) => ({ type, name, order: 8, pageSize, pageNo: 1, search: 1, tagGroup: 0, tagModules: ['ebuilderform'] });
+    const rs = await Promise.all([0, 1].map((type) => env.host
+        .request({
         path: '/api/my/tag/query',
         method: 'POST',
-        body: { tagModules: ['ebuilderform'], current: 1, pageSize: 500 },
+        body: bodyOf(type),
         operation: 'ehr.recruit.candidate.import.apply',
-    }));
-    const rows = list?.data?.data || list?.data?.list || [];
+    })
+        .catch(() => null)));
+    const items = [];
+    let filtered = true;
+    for (const r of rs) {
+        const d = r?.data || {};
+        const list = Array.isArray(d.data) ? d.data : [];
+        const total = Number(d.total || 0);
+        if (list.length >= pageSize && total >= pageSize)
+            filtered = false;
+        items.push(...list);
+    }
+    return { items, filtered };
+}
+/** 单类型的全量标签（首轮取 total 后并发翻页，限并发 5、上限 40 页）——仅在按名查询不可用时回退 */
+async function fetchTagsOfType(env, type) {
+    const pageSize = 100;
+    const bodyOf = (pageNo) => ({ type, name: '', order: 8, pageSize, pageNo, search: 1, tagGroup: 0, tagModules: ['ebuilderform'] });
+    const requestPage = (pageNo) => env.host
+        .request({
+        path: '/api/my/tag/query',
+        method: 'POST',
+        body: bodyOf(pageNo),
+        operation: 'ehr.recruit.candidate.import.apply',
+    })
+        .catch(() => null);
+    const first = (await requestPage(1));
+    const d = first?.data || {};
+    const rows = Array.isArray(d.data) ? [...d.data] : [];
+    const total = Number(d.total || 0);
+    const pages = Math.min(40, Math.max(1, Math.ceil(total / pageSize)));
+    if (pages > 1 && rows.length) {
+        const rest = Array.from({ length: pages - 1 }, (_, i) => i + 2);
+        for (let i = 0; i < rest.length; i += 5) {
+            const batch = rest.slice(i, i + 5);
+            const rs = await Promise.all(batch.map((p) => requestPage(p)));
+            for (const r of rs) {
+                const list = r?.data?.data;
+                if (Array.isArray(list))
+                    rows.push(...list);
+            }
+        }
+    }
+    return rows;
+}
+/** 解析标签名 → id（同名优先公共），不创建标签。
+ *  ① 按名精确查询（N 个名字 → 1 轮请求）；② 服务端未按名过滤时才回退全量（不落盘、不缓存）。 */
+async function resolveTagIds(env, tagNames) {
+    const norm = (s) => String(s == null ? '' : s).trim().toLowerCase();
+    const uniqNames = [...new Set(tagNames.map((n) => String(n)).filter(Boolean))];
     const byName = new Map();
-    for (const row of rows) {
-        const name = String(row.name ?? row.tagName ?? '').trim();
-        const id = row.tagId ?? row.id;
-        if (name && id !== undefined && !byName.has(name))
-            byName.set(name, { id: String(id), name });
-    }
-    const tags = [];
-    const applied = [];
+    const absorb = (row) => {
+        const name = String(row?.name ?? row?.tagName ?? '').trim();
+        const id = row?.tagId ?? row?.id;
+        if (!name || id === undefined)
+            return;
+        const key = norm(name);
+        const prev = byName.get(key);
+        if (!prev)
+            byName.set(key, { id: String(id), name });
+        else if ((row?.type ?? 0) === 0)
+            byName.set(key, { id: String(id), name });
+    };
+    const probes = await Promise.all(uniqNames.map((n) => queryTagByName(env, n)));
+    const nameQueryUsable = probes.every((p) => p.filtered);
+    if (nameQueryUsable) {
+        for (const p of probes)
+            for (const item of p.items)
+                absorb(item);
+    }
+    else {
+        for (const type of [0, 1]) {
+            const rows = await fetchTagsOfType(env, type).catch(() => []);
+            for (const item of rows)
+                absorb(item);
+        }
+    }
+    const resolved = [];
+    const found = [];
     const skipped = [];
     for (const name of tagNames) {
-        const hit = byName.get(name);
+        const hit = byName.get(norm(name));
         if (!hit) {
             skipped.push(name);
             continue;
         }
-        tags.push({ id: hit.id, name: hit.name, type: 0 });
-        applied.push(name);
+        resolved.push({ id: hit.id, name: hit.name, type: 0 });
+        found.push(name);
     }
-    if (tags.length) {
+    return { resolved, found, skipped };
+}
+/** 写入平台标签（解析 + batchAddEntityTag）。解析结果不存在时静默跳过，不自动创建标签。 */
+async function applyPlatformTags(env, talentId, tagNames) {
+    if (!tagNames.length)
+        return { applied: [], skipped: [] };
+    const r = await resolveTagIds(env, tagNames);
+    if (r.resolved.length) {
         await env.host.request({
             path: '/api/my/tag/common/batchAddEntityTag',
             method: 'POST',
-            body: { tags, batchDatas: [{ entityId: talentId, module: 'ebuilderform' }] },
+            body: { tags: r.resolved, batchDatas: [{ entityId: talentId, module: 'ebuilderform' }] },
             operation: 'ehr.recruit.candidate.import.apply',
         });
     }
-    return { applied, skipped };
+    return { applied: r.found, skipped: r.skipped };
 }
 async function requireCache(env) {
     if (!env.recruitContext)
@@ -387,6 +592,9 @@ function str(value) {
 }
 async function buildImportPlan(env, cache, args) {
     const warnings = [];
+    // 日期格式预检与归一：必须在构建主表/明细之前执行。原实现直接把模型给的
+    // 「2020.11」「2004.09-2008.07」写进接口，导致 dataset 整批校验失败、明细全丢。
+    normalizeImportDates(args, warnings);
     const talent = cache.forms.talent_pool;
     const objId = talent?.objId;
     const formId = talent?.formId || objId;
@@ -582,7 +790,16 @@ const candidateImportPrepare = {
     handler: async (args, env) => {
         const cache = await requireCache(env);
         const plan = await buildImportPlan(env, cache, args);
-        const dup = await checkDuplicateByMobile(env, cache, plan.mobile);
+        // 标签预检（只读）+ 查重并行：让用户在确认摘要里就能看到哪些标签在本环境不存在（apply 会跳过它们）
+        const tagNames = Array.isArray(args.tags) ? args.tags.map(String).filter(Boolean) : [];
+        const [dup, tagCheck] = await Promise.all([
+            checkDuplicateByMobile(env, cache, plan.mobile),
+            tagNames.length
+                ? resolveTagIds(env, tagNames)
+                    .then((rt) => ({ requested: tagNames, found: rt.found, missing: rt.skipped }))
+                    .catch((error) => ({ requested: tagNames, missing: [], error: error?.message || '标签预检失败' }))
+                : Promise.resolve(null),
+        ]);
         if (dup.length > 1) {
             throw ehrValidationError('duplicate_ambiguous', `手机号 ${plan.mobile} 存在多条候选（数据异常），请人工核对后再决定，不自动新建`);
         }
@@ -605,7 +822,7 @@ const candidateImportPrepare = {
                 candidateName: plan.talentName,
                 telephone: plan.mobile,
             },
-        }, 10 * 60 * 1000);
+        }, CONTINUATION_TTL_MS);
         return ehrSuccess('ehr.recruit.candidate.import.prepare', {
             status: 'AWAITING_CONFIRMATION',
             preview: {
@@ -621,8 +838,9 @@ const candidateImportPrepare = {
                 details: plan.details,
                 tags: Array.isArray(args.tags) ? args.tags : [],
             },
+            ...(tagCheck ? { tagCheck } : {}),
             continuation,
-            expiresInSeconds: 600,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
         });
     },
 };
@@ -684,43 +902,31 @@ const candidateImportApply = {
                 throw error;
             throw ehrPartialError(`简历建档写入结果不确定（${error?.message || '未知错误'}）：请先用人才库搜索手机号 ${payload.telephone} 核对是否已建档，禁止直接重试`, { candidateName: payload.candidateName, telephone: payload.telephone });
         }
-        // ③ 初始化人才批次（失败不回滚人才，仅记 warning）
-        let batchOk = null;
-        let batchNote;
-        try {
-            await env.host.request({
-                path: `/api/recruit/candidate/initTalentBatch?formDataId=${encodeURIComponent(talentId)}`,
-                method: 'POST',
-                operation: 'ehr.recruit.candidate.import.apply',
-            });
-            batchOk = true;
-        }
-        catch (error) {
-            batchOk = false;
-            batchNote = `人才已建档，但初始化人才批次失败：${error?.message || '未知错误'}（可在人才卡片手动处理）`;
-        }
-        // ④ 触发后台智能标签规则（规则未配置时不产生标签，属正常）
-        let labelMatch = null;
-        try {
-            const r = (await env.host.request({
-                path: `/api/recruit/label/matchTalentLabel?talentId=${encodeURIComponent(talentId)}`,
-                method: 'POST',
-                body: {},
-                operation: 'ehr.recruit.candidate.import.apply',
-            }));
-            labelMatch = r?.data === undefined ? 'TRIGGERED' : String(r.data);
-        }
-        catch {
-            labelMatch = 'FAILED（不影响建档，可稍后在人才卡片手动触发）';
-        }
-        // ⑤ 平台标签（按名命中清单写入，不存在则跳过）
-        let tagResult = { applied: [], skipped: [] };
-        try {
-            tagResult = await applyPlatformTags(env, talentId, Array.isArray(payload.tags) ? payload.tags.map(String) : []);
-        }
-        catch (error) {
-            tagResult = { applied: [], skipped: Array.isArray(payload.tags) ? payload.tags.map(String) : [] };
-        }
+        // ③④⑤ 初始化批次 / 触发电商后台标签规则 / 平台标签：三者只依赖 talentId，并行执行（各自 catch 等价原语义）
+        const batchTask = env.host
+            .request({
+            path: `/api/recruit/candidate/initTalentBatch?formDataId=${encodeURIComponent(talentId)}`,
+            method: 'POST',
+            operation: 'ehr.recruit.candidate.import.apply',
+        })
+            .then(() => ({ ok: true, note: undefined }))
+            .catch((error) => ({
+            ok: false,
+            note: `人才已建档，但初始化人才批次失败：${error?.message || '未知错误'}（可在人才卡片手动处理）`,
+        }));
+        const labelTask = env.host
+            .request({
+            path: `/api/recruit/label/matchTalentLabel?talentId=${encodeURIComponent(talentId)}`,
+            method: 'POST',
+            body: {},
+            operation: 'ehr.recruit.candidate.import.apply',
+        })
+            .then((r) => (r?.data === undefined ? 'TRIGGERED' : String(r.data)))
+            .catch(() => 'FAILED（不影响建档，可稍后在人才卡片手动触发）');
+        const tagTask = applyPlatformTags(env, talentId, Array.isArray(payload.tags) ? payload.tags.map(String) : []).catch(() => ({ applied: [], skipped: Array.isArray(payload.tags) ? payload.tags.map(String) : [] }));
+        const [batchOutcome, labelMatch, tagResult] = await Promise.all([batchTask, labelTask, tagTask]);
+        const batchOk = batchOutcome.ok;
+        const batchNote = batchOutcome.note;
         // ⑥ 产物链接：人才卡片单页 + 人才库列表定位（自用系统追加 recruitType=useSelf）
         const baseUrl = session.baseUrl.replace(/\/+$/, '');
         const extra = String(cache.selfUse) === '1' ? '&recruitType=useSelf' : '';
@@ -734,13 +940,61 @@ const candidateImportApply = {
         const warnings = [...(payload.warnings || [])];
         if (batchNote)
             warnings.push(batchNote);
+        // 明细完整性判定（2026-11-05 与 recruit-stage 同步修复）：
+        // 主表建成 ≠ 建档成功。原实现 result 硬编码 'success' 且从不回读明细，
+        // 一旦日期格式等原因导致明细整批被拒，会出现「人才已建、经历全空」却仍报成功的静默事故。
+        // 规则：期望行数 > 0 时读回行数必须 >= 期望，否则 result 只能报 partial；回读失败标 unverified。
+        let detailsState = 'complete';
+        const expectedDetailRows = Object.values(payload.subStats || {}).reduce((sum, n) => sum + Number(n || 0), 0);
+        if (expectedDetailRows > 0) {
+            try {
+                const snapshot = (await env.host.request({
+                    path: '/api/ebuilder/form/form/core/getFormDataAndLayout',
+                    method: 'POST',
+                    body: {
+                        terminalType: 'PC',
+                        dataId: talentId,
+                        formId,
+                        module: 'ebuilderform',
+                        newLayout: true,
+                        dataCrossLayout: false,
+                        permissionId: '',
+                        allReadOnly: true,
+                        initialDatas: [],
+                        dynamicData: false,
+                        cost: false,
+                        customParam: { objId, dataId: talentId },
+                    },
+                    operation: 'ehr.recruit.candidate.import.apply',
+                }));
+                const detailData = snapshot?.data?.formData?.dataDetails || [];
+                const seenRows = {};
+                for (const d of detailData) {
+                    if (!d?.subFormId)
+                        continue;
+                    const key = String(d.subFormId);
+                    (seenRows[key] = seenRows[key] || new Set()).add(String(d.dataIndex));
+                }
+                const gotRows = Object.values(seenRows).reduce((sum, set) => sum + set.size, 0);
+                if (gotRows < expectedDetailRows) {
+                    detailsState = 'missing';
+                    warnings.push(`明细行未完整落库（期望 ${expectedDetailRows} 行，读回 ${gotRows} 行）：主表已写入，请核对后补齐明细`);
+                }
+            }
+            catch (error) {
+                detailsState = 'unverified';
+                warnings.push(`明细读回校验失败（无法确认明细是否落库）：${error?.message || '未知错误'}`);
+            }
+        }
         return ehrSuccess('ehr.recruit.candidate.import.apply', {
-            result: 'success',
+            result: detailsState === 'complete' ? 'success' : 'partial',
+            detailsState,
             talentId,
             candidateName: payload.candidateName,
             telephone: payload.telephone,
             mainTableFields: Object.keys(mainTable).length,
             detailRows: payload.subStats || undefined,
+            detailRowsExpected: expectedDetailRows || undefined,
             attachment: uploaded ? { name: uploaded.name, size: uploaded.size } : null,
             batch: { ok: batchOk, note: batchNote },
             labelMatch,

package/dist/shortcuts/ehr/operations/recruit-position.js

@@ -1,3 +1,4 @@
+import { CONTINUATION_TTL_MS, CONTINUATION_TTL_SECONDS } from '../../../core/continuation-ttl.js';
 import { createHash } from 'node:crypto';
 import { ehrConfirmationError, ehrValidationError } from '../errors.js';
 import { WRITE, SCHEMA_ID, ehrSuccess, schemaOf, } from './types.js';
@@ -25,6 +26,10 @@ const TEXT_KEYS = ['position_name'];
 const MTEXT_KEYS = ['position_duty', 'work_request'];
 const ASSOC_KEYS = ['demand'];
 const PERSON_DEFAULT_KEYS = ['recr_principal', 'employ_manager'];
+// 🔴 薪资（salary_min / salary_max）必须沿用现值，不能留空：
+// 这两个字段是**表单必填项**，不传就会导致后端必填校验失败、整个建职位流程直接报错。
+// 但历史职位薪资确实可能是脏数据（实测抓到过 300 元月薪），因此不静默使用——
+// 通过 summary.inheritedFromRef 逐项暴露给用户核对，并对明显偏低的值追加 inheritedSalaryWarnings 提示。
 const REF_COPY_KEYS = [
     'position_nature',
     'job_category',
@@ -41,6 +46,7 @@ const OPTION_DEFAULTS = { salary_type: '月薪', recruit_type: '社会招聘', s
 const SET_FIELDS = [
     { arg: 'education', key: 'education', kind: 'dict', label: '学历要求（按数据字典名称）' },
     { arg: 'workYears', key: 'work_years', kind: 'dict', label: '工作年限（按数据字典名称）' },
+    { arg: 'workLocation', key: 'work_location', kind: 'assoc', label: '工作地点（办公地点名称/详细地址，如「上海」或完整地址）' },
     { arg: 'jobCategory', key: 'job_category', kind: 'dict', label: '职位类别（按数据字典名称）' },
     { arg: 'positionNature', key: 'position_nature', kind: 'dict', label: '职位属性（按数据字典名称）' },
     { arg: 'salaryType', key: 'salary_type', kind: 'option', label: '薪酬类型（月薪/年薪等）' },
@@ -95,6 +101,105 @@ async function fetchReferenceDetails(env, cache, objId, formId) {
         return [];
     }
 }
+const WORK_PLACE_NAMES = ['办公地点', '工作地点'];
+/** 「办公地点」菜单定位：三级来源（lists.all_search → cache.menus（若存在）→ allMenus 接口），不依赖单一缓存键。
+ *  背景同 recruit-stage：原实现直接读 cache.menus，而该环境缓存没有 menus 字段 → 恒取不到 → 工作地点永远写不进去。 */
+async function findWorkPlaceMenu(env, cache) {
+    const ok = (m) => !!(m && m.listId);
+    const pick = (list) => {
+        const hit = list.find((m) => ok(m) && WORK_PLACE_NAMES.some((n) => String(m.menuName || '').includes(n)));
+        return hit ? hit : null;
+    };
+    // ① 环境缓存 all_search（与面试数字人菜单同一模式）
+    const hit1 = pick((cache.lists?.all_search || []));
+    if (hit1)
+        return hit1;
+    // ② legacy menus（部分环境可能有）
+    const hit2 = pick((cache.menus || []));
+    if (hit2)
+        return hit2;
+    // ③ allMenus 接口兜底
+    try {
+        const r = (await env.host.request({
+            path: '/api/cusapp/app/allMenus',
+            query: { isFront: 1, appId: String(cache.appId || ''), terminalType: 'PC' },
+        }));
+        const flat = [];
+        (function walk(nodes) {
+            for (const n of nodes || []) {
+                if (n && typeof n === 'object') {
+                    flat.push(n);
+                    walk(n.children || n.childs);
+                }
+            }
+        })((r?.data?.cusAppMenus || r?.data));
+        return pick(flat);
+    }
+    catch {
+        return null;
+    }
+}
+/** 工作地点：按名称/详细地址/区域文本解析「办公地点」记录 id；解析不到返回 null（调用方进 setSkipped，不臆造 id）。 */
+async function resolveWorkLocation(env, cache, value) {
+    const v = String(value).trim();
+    if (!v)
+        return null;
+    const menu = await findWorkPlaceMenu(env, cache);
+    if (!menu?.listId)
+        return null;
+    let pObj = '';
+    try {
+        const t = (await env.host.request({
+            path: '/api/ebuilder/form/obj/getObjsByTag',
+            query: { appId: String(cache.appId || ''), tag: 'uf_rcrt_work_place' },
+        }));
+        const d = t?.data;
+        if (Array.isArray(d) && d[0])
+            pObj = String(d[0].id || '');
+    }
+    catch {
+        /* tag 未注册：用菜单节点兜底 */
+    }
+    if (!pObj)
+        pObj = String(menu.objId || '');
+    if (!pObj)
+        return null;
+    const body = buildListBody({
+        listId: menu.listId,
+        cusMenuId: menu.cusMenuId,
+        menuName: menu.menuName || '办公地点',
+        title: menu.menuName || '办公地点',
+        pageSize: 200,
+    });
+    const r = (await env.host.request({
+        path: `/api/ebuilder/form/list/getListDatas?passid=${pObj}&cid=${pObj}`,
+        body,
+        headers: { ebBusinessId: menu.listId },
+    }));
+    const rows = (r?.data?.data || r?.data?.displayData || []);
+    const hit = rows.find((x) => {
+        const name = String(x?.name || '');
+        const detail = String(x?.detail_location || '');
+        const area = String(x?.area_text || '');
+        return name.includes(v) || detail.includes(v) || area.includes(v) || (!!detail && v.includes(detail));
+    });
+    return hit ? { id: String(hit.form_data_id || hit.id), name: String(hit.detail_location || hit.name || v) } : null;
+}
+/** 从提交 detail 取可读值（用于 summary 里点名「继承来的值」） */
+function detailDisplayValue(detail) {
+    if (!detail)
+        return '';
+    const d = detail;
+    if (d.content !== undefined && d.content !== null)
+        return String(d.content);
+    if (Array.isArray(d.dataOptions) && d.dataOptions[0]) {
+        const o = d.dataOptions[0];
+        return String(o.content ?? o.optionId ?? '');
+    }
+    if (d.dataText?.content !== undefined)
+        return String(d.dataText.content).replace(/<[^>]+>/g, '').slice(0, 60);
+    return '';
+}
 async function buildPositionPlan(env, cache, args) {
     const form = cache.forms.position_manage;
     const objId = form?.objId;
@@ -169,6 +274,15 @@ async function buildPositionPlan(env, cache, args) {
             put({ formField: { id: fieldId }, dataOptions: [{ optionId: String(optionId), content: value }] });
             applied.push(`${field.key}=${value}`);
         }
+        else if (field.kind === 'assoc') {
+            const loc = await resolveWorkLocation(env, cache, value);
+            if (!loc) {
+                skipped.push(`${field.key}=${value}（未匹配到「办公地点」记录，已跳过）`);
+                continue;
+            }
+            put({ formField: { id: fieldId }, dataOptions: [{ optionId: loc.id, content: loc.name }] });
+            applied.push(`${field.key}=${value}`);
+        }
         else if (field.kind === 'dict') {
             const ids = cache.dict.by_name[value] || [];
             const unique = [...new Set(ids.map(String))];
@@ -237,6 +351,18 @@ async function buildPositionPlan(env, cache, args) {
     const inverse = {};
     for (const [dataKey, fieldId] of Object.entries(fields))
         inverse[String(fieldId)] = dataKey;
+    // 继承来的薪资若明显偏低（历史脏数据，实测出现过 300 元月薪），额外点名提示。
+    // 不阻断提交（薪资是必填项，阻断等于无法建档），但要求 Agent 在确认摘要里明确提示用户核对。
+    const inheritedSalaryWarnings = [];
+    for (const key of ['salary_min', 'salary_max']) {
+        if (!inherited.includes(key))
+            continue;
+        const raw = detailDisplayValue(refMap.get(String(fid(key))));
+        const num = Number(String(raw).replace(/[^\d.]/g, ''));
+        if (raw && Number.isFinite(num) && num > 0 && num < 1000) {
+            inheritedSalaryWarnings.push(`${key} 继承值「${raw}」明显偏低（疑历史脏数据），请人工核对后再提交`);
+        }
+    }
     return {
         objId,
         formId,
@@ -250,6 +376,12 @@ async function buildPositionPlan(env, cache, args) {
             explicitApplied: applied,
             explicitSkipped: skipped,
             inheritedFromExistingPosition: inherited,
+            // 带值的继承清单：Agent 必须在确认摘要里逐项点名（尤其 work_location），
+            // 不得因为它是默认值就略过——历史上这里曾静默带出过重复地点等脏数据。
+            inheritedFromRef: inherited.length
+                ? inherited.map((k) => ({ field: k, value: detailDisplayValue(refMap.get(String(fid(k)))) }))
+                : undefined,
+            inheritedSalaryWarnings: inheritedSalaryWarnings.length ? inheritedSalaryWarnings : undefined,
             noReferenceValue: missingRef,
             principalDefault: session.userId ? '当前登录用户' : '未解析到当前用户',
         },
@@ -283,13 +415,13 @@ const positionCreatePrepare = {
             userId: session.userId,
             payload: { objId: plan.objId, formId: plan.formId, positionName: String(args.positionName).trim(), dataDetails: plan.dataDetails },
             fingerprint: fingerprint({ objId: plan.objId, dataDetails: plan.dataDetails }),
-        }, 10 * 60 * 1000);
+        }, CONTINUATION_TTL_MS);
         return ehrSuccess('ehr.recruit.position.create.prepare', {
             status: 'AWAITING_CONFIRMATION',
             preview: { action: '生成职位JD并建职位（saveFormData → addPosition）', ...plan.summary },
             willSubmit: { objId: plan.objId, formId: plan.formId, dataDetails: plan.dataDetails },
             continuation,
-            expiresInSeconds: 600,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
         });
     },
 };