weaver-work-cli 0.1.39 → 0.1.42

package/dist/shortcuts/recruit-stage/operations/jd-create.js

@@ -0,0 +1,630 @@
+/**
+ * recruit-stage.jd.create.* —— 生成职位 JD / 创建职位（写操作，自 recruit-generate-jd.mjs 1:1 移植）
+ *
+ * 链路：① saveFormData(职位管理 uf_rcrt_position_manage) → ② addPosition?formDataId 提交生成职位
+ *
+ * 三种操作：
+ *   .prepare  只出确认摘要（不写库），签发 continuation（写操作红线：先确认后落库）
+ *   .apply    用户确认后执行（confirm:true + continuation + 摘要指纹比对）
+ *   .prefill  预填模式（人工保存）：输出新建页 URL + WeFormSDK 注入脚本，不落库
+ *
+ * 字段 id 全部经环境缓存 fields[objId] 运行时取，不写死。
+ * 多行文本字段（position_duty/work_request）走 dataText；单行文本（position_name）走 content；
+ * 关联类字段（demand/status/recruit_flow）走 dataOptions。
+ *
+ * sets 覆盖（"贴合 JD 型"）：AI 读 JD 后按字段语义传值，按字段取值类别自动解析 optionId：
+ *   数值型→content；人员型→按姓名解析 userId；枚举型→ds/options；字典引用型→数据字典；
+ *   关联表单型 work_location→「办公地点」解析；其它→content。
+ *
+ * 默认值策略（跨环境运行时解析、不写死 id）：状态=招聘中；流程=环境默认启用流程；
+ * 人数=1、薪酬月数=12；薪酬类型=月薪、招聘方式=社会招聘；
+ * 招聘负责人/用人经理=当前登录用户；其余关联表单型取环境内已有职位记录的值（"默认值=系统现成值"）。
+ */
+import { createHash, randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { resolve as resolvePath, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { rsSuccess, schemaOf } from './types.js';
+import { rsFail, rsValidationError, rsConfirmationError } from '../errors.js';
+import { objIdOf, formIdOf, saveFormData, getDsOptions, cachedDsMap, getFormDataRecord, resolvePersonId, findMenuNode, resolveCurrentUser, buildCardUrl, buildListLocateUrl, randHex32, } from '../shared.js';
+const SCHEMA_ID_STR = { type: 'string', description: '18 位记录 id（字符串）' };
+// 职位管理表单字段 dataKey（缓存 fields 里取；不写死 fieldId）
+const DATAKEYS_TEXT = ['position_name'];
+const DATAKEYS_MTEXT = ['position_duty', 'work_request'];
+// 必填字段默认值策略
+const DEF_TEXT = { recruit_count: '1', number_of_pay_months: '12' };
+const DEF_OPTION = { salary_type: '月薪', recruit_type: '社会招聘' };
+const DEF_CURRENT_USER = ['recr_principal', 'employ_manager'];
+const DEF_FROM_REF = [
+    'position_nature', 'job_category', 'education', 'work_years', 'work_location',
+    'salary_min', 'salary_max',
+];
+const DEF_STATUS = '招聘中';
+// sets 覆盖解析：字段取值类别
+const NUM_KEYS = new Set(['recruit_count', 'number_of_pay_months', 'salary_min', 'salary_max', 'internship_duration', 'working_days']);
+const PERSON_KEYS = new Set(['recr_principal', 'recr_helper', 'employ_manager', 'interviewer']);
+const OPTION_KEYS = new Set(['salary_type', 'recruit_type', 'status']);
+const DICT_KEYS = new Set(['position_nature', 'job_category', 'education', 'work_years']);
+const MTEXT_KEYS = new Set(['position_duty', 'work_request']);
+function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function detailValueId(d) {
+    if (!d)
+        return '';
+    if (d.dataOptions && d.dataOptions[0])
+        return String(d.dataOptions[0].optionId || '');
+    if (d.dataText)
+        return String(d.dataText.content || '');
+    if (d.content !== undefined)
+        return String(d.content);
+    return '';
+}
+function dictGroupOf(cache, valueId) {
+    const row = (cache.dict?.raw || []).find((x) => String(x.option_id) === String(valueId));
+    return row ? String(row.dict_type) : '';
+}
+function dictIdByName(cache, name, group) {
+    const rows = (cache.dict?.raw || []).filter((x) => x.selection_name === name && (!group || String(x.dict_type) === group));
+    return rows.length ? String(rows[0].option_id) : '';
+}
+// 取环境内一条「字段较全」的职位记录的全部字段（ret: { fid: detail }），保证引用有效
+async function fetchRefByFid(ctx) {
+    const { host, cache } = ctx;
+    const objId = objIdOf(cache, 'position_manage');
+    const formId = formIdOf(cache, 'position_manage');
+    const posMenu = cache.lists?.position || null;
+    if (!posMenu)
+        return {};
+    const body = {
+        current: 1, pageSize: 20, tableuid: randHex32(),
+        listId: posMenu.listId, searchParamData: { searchType: '3', type: 'and' },
+        terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1,
+        recheckQuery: 1, isFollow: 0, isShareToMe: 0, filterCondition: {},
+        cusMenuId: posMenu.cusMenuId, urlPageTitle: '招聘职位', menuName: '招聘职位',
+    };
+    const r = await host.request({
+        path: `/api/ebuilder/form/list/getListDatas?passid=${objId}&cid=${objId}`,
+        body, headers: { ebBusinessId: posMenu.listId },
+    });
+    const rows = r?.data?.data || [];
+    const ref = rows.find((x) => x.form_data_id && x.position_nature);
+    if (!ref)
+        return {};
+    const rec = await getFormDataRecord(host, formId, String(ref.form_data_id), objId);
+    const byFid = {};
+    for (const d of rec.dataDetails || []) {
+        const f = String(d.fieldId || d.formField?.id || '');
+        if (f)
+            byFid[f] = d;
+    }
+    return byFid;
+}
+// ref 记录 detail → 提交 detail（保留 dataOptions/dataText/content 形态）
+function refToSubmit(d) {
+    const o = { formField: { id: String(d.fieldId || d.formField?.id) } };
+    if (d.dataOptions)
+        o.dataOptions = d.dataOptions;
+    else if (d.dataText)
+        o.dataText = d.dataText;
+    else if (d.content !== undefined && d.content !== '')
+        o.content = d.content;
+    else if (d.value !== undefined && d.value !== '')
+        o.dataText = { content: String(d.value) };
+    else
+        return null;
+    return o;
+}
+// 工作地点：按名称/详细地址/城市解析「办公地点」记录 id（tag uf_rcrt_work_place → 表单 → 列表匹配）
+async function resolveWorkLocation(ctx, value) {
+    const { host, appId, cache } = ctx;
+    const t = await host.request({ path: `/api/ebuilder/form/obj/getObjsByTag?appId=${appId}&tag=uf_rcrt_work_place`, method: 'GET' });
+    const d = t?.data;
+    const pObj = (Array.isArray(d) && d[0]) ? String(d[0].id || '') : '';
+    const menu = findMenuNode(cache.menus || [], ['办公地点', '工作地点'], (m) => m.listId && m.cusMenuId);
+    if (!pObj || !menu)
+        return null;
+    const body = {
+        current: 1, pageSize: 200, tableuid: randHex32(),
+        listId: menu.listId, searchParamData: { searchType: '3', type: 'and' },
+        terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1,
+        recheckQuery: 1, isFollow: 0, isShareToMe: 0, filterCondition: {},
+        cusMenuId: menu.cusMenuId, urlPageTitle: menu.menuName, menuName: menu.menuName,
+    };
+    const r = await host.request({ path: `/api/ebuilder/form/list/getListDatas?passid=${pObj}&cid=${pObj}`, body, headers: { ebBusinessId: menu.listId } });
+    const rows = r?.data?.data || [];
+    const v = String(value).trim();
+    const hit = rows.find((x) => {
+        const name = String(x.name || ''), detail = String(x.detail_location || ''), 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;
+}
+// 解析 sets key=value → 提交 detail（按字段取值类别；解析不到返回 null）
+async function resolveSetValue(ctx, key, value, refByFid) {
+    const { host, appId, cache } = ctx;
+    const objId = objIdOf(cache, 'position_manage');
+    const id = (cache.fields[objId] || {})[key];
+    if (!id)
+        return null;
+    if (NUM_KEYS.has(key))
+        return { formField: { id }, content: String(value) };
+    if (MTEXT_KEYS.has(key))
+        return { formField: { id }, dataText: { content: String(value) } };
+    if (key === 'position_name')
+        return { formField: { id }, content: String(value) };
+    if (PERSON_KEYS.has(key)) {
+        const uid = await resolvePersonId(host, id, value);
+        return uid ? { formField: { id }, dataOptions: [{ optionId: String(uid), content: value }] } : null;
+    }
+    if (OPTION_KEYS.has(key)) {
+        const m = cachedDsMap(cache, objId, key) || await getDsOptions(host, objId, id, appId);
+        const oid = m[value];
+        return oid ? { formField: { id }, dataOptions: [{ optionId: String(oid), content: value }] } : null;
+    }
+    if (DICT_KEYS.has(key)) {
+        const group = dictGroupOf(cache, detailValueId(refByFid[String(id)]));
+        const did = dictIdByName(cache, value, group) || dictIdByName(cache, value, '');
+        return did ? { formField: { id }, dataOptions: [{ optionId: String(did), content: value }] } : null;
+    }
+    if (key === 'work_location') {
+        const loc = await resolveWorkLocation(ctx, value);
+        return loc ? { formField: { id }, dataOptions: [{ optionId: loc.id, content: loc.name }] } : null;
+    }
+    return { formField: { id }, content: String(value) };
+}
+// ── 预填（人工保存）模式：dataDetails → WeFormSDK.changeFieldValue 的 (mark, info) ──
+function toPrefillFields(dataDetails, fields) {
+    const inv = {};
+    for (const [k, v] of Object.entries(fields))
+        inv[String(v)] = k;
+    const personFids = new Set(Object.keys(fields).filter((k) => PERSON_KEYS.has(k)).map((k) => String(fields[k])));
+    const out = [];
+    for (const d of dataDetails) {
+        const fid = String(d.formField.id);
+        let info = null;
+        if (d.dataOptions)
+            info = { specialObj: d.dataOptions.map((o) => ({ id: String(o.optionId), name: o.content, ...(personFids.has(fid) ? { type: 'user' } : {}) })) };
+        else if (d.dataText)
+            info = { value: String(d.dataText.content) };
+        else if (d.content !== undefined)
+            info = { value: String(d.content) };
+        if (info)
+            out.push({ mark: 'field' + fid, info, label: inv[fid] || fid });
+    }
+    return out;
+}
+// 职位管理「新建页」URL：从 allMenus 解析职位列表菜单（别名匹配，跨环境不写死）
+async function resolvePositionNewUrl(ctx) {
+    const { host, appId, baseUrl, cache } = ctx;
+    const cached = cache.menus?.find?.((m) => m.combinationId && m.id && m.pageId && ['招聘职位', '职位列表', '职位管理'].some((n) => (m.menuName || '').includes(n)));
+    let node = cached || null;
+    if (!node) {
+        const r = await host.request({ path: `/api/cusapp/app/allMenus?isFront=1&appId=${appId}&terminalType=PC`, method: 'GET' });
+        const flat = [];
+        (function walk(ns) { for (const n of (ns || []))
+            if (n && typeof n === 'object') {
+                flat.push(n);
+                walk(n.children || n.childs);
+            } })(r?.data?.cusAppMenus || r?.data);
+        node = findMenuNode(flat, ['招聘职位', '职位列表', '职位管理'], (n) => n.combinationId && n.id && n.pageId);
+    }
+    if (!node)
+        return null;
+    return `${baseUrl}/ebdapp/view/${appId}/combination/${node.combinationId}-${node.id}/search/${node.pageId}?terminal=PC&cusMenuId=${node.id}`;
+}
+// 招聘首页（PAGE 型）URL
+async function resolveHomePageUrl(ctx) {
+    const { host, appId, baseUrl } = ctx;
+    const r = await host.request({ path: `/api/cusapp/app/allMenus?isFront=1&appId=${appId}&terminalType=PC`, method: 'GET' });
+    const flat = [];
+    (function walk(ns) { for (const n of (ns || []))
+        if (n && typeof n === 'object') {
+            flat.push(n);
+            walk(n.children || n.childs);
+        } })(r?.data?.cusAppMenus || r?.data);
+    const node = findMenuNode(flat, ['招聘首页', '招聘主页'], (n) => n.pageType === 'PAGE' && n.pageId && n.id)
+        || flat.find((n) => n.pageType === 'PAGE' && String(n.menuName || '').includes('首页'));
+    if (!node || !node.pageId || !node.id)
+        return null;
+    return `${baseUrl}/ebdapp/view/${appId}/PAGE/${node.pageId}-${node.id}?terminal=PC&cusMenuId=${node.id}&appId_${node.pageId}=${appId}`;
+}
+// 参考同类职位：抓最近一页职位列表（displayData 已是服务端翻译后的可读文本），按关键词客户端过滤
+// 取前 5 条，再逐条拉记录详情取薪酬与职责/要求正文。供 AI 在确认摘要里给出「最近同类职位参考」。
+const REF_DETAIL_KEYS = ['salary_type', 'salary_min', 'salary_max', 'number_of_pay_months', 'education',
+    'work_years', 'recruit_count', 'recruit_type', 'position_nature', 'work_location', 'department', 'sub_company'];
+const REF_TEXT_KEYS = ['position_duty', 'work_request'];
+async function fetchRecentReferences(ctx, jd, keyword) {
+    const { host, cache } = ctx;
+    const listParam = cache.lists?.position || null;
+    if (!listParam?.listId)
+        return { available: false, reason: '环境缓存缺少职位列表参数', items: [] };
+    const r = await host.request({
+        path: '/api/ebuilder/form/list/getListDatas?passid=' + jd.objId + '&cid=' + jd.objId,
+        body: {
+            current: 1, pageSize: 30, tableuid: randHex32(), listId: listParam.listId,
+            searchParamData: { searchType: '3', type: 'and' },
+            terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1, recheckQuery: 1,
+            isFollow: 0, isShareToMe: 0, filterCondition: {},
+            cusMenuId: listParam.cusMenuId, urlPageTitle: listParam.menuName, menuName: listParam.menuName,
+        },
+        headers: { ebBusinessId: listParam.listId },
+    });
+    const rows = r?.data?.displayData || r?.data?.data || [];
+    const kw = String(keyword || '').trim();
+    const tokens = [...new Set(kw.split(/[^A-Za-z0-9\u4e00-\u9fff]+/).concat(kw).map((t) => t.trim()).filter((t) => t.length >= 2))];
+    const match = (row) => {
+        if (!tokens.length)
+            return true;
+        const name = String(row.position_name || row.name || '');
+        const hay = name + ' ' + Object.values(row.displayData || {}).map(String).join(' ');
+        return tokens.some((t) => hay.toUpperCase().includes(t.toUpperCase()));
+    };
+    const fields = cache.fields[jd.objId] || {};
+    const rev = {};
+    for (const [k, v] of Object.entries(fields))
+        rev[String(v)] = k;
+    const picked = [];
+    for (const row of rows) {
+        if (!match(row) || picked.length >= 5)
+            continue;
+        const dataId = String(row.form_data_id || row.id || '');
+        if (!dataId || dataId === String(jd.dataId || ''))
+            continue;
+        const item = {
+            职位: String(row.position_name || row.name || '').trim(),
+            状态: String(row.status || row.data_status_value || '').trim(),
+            创建时间: String(row.create_time || '').trim(),
+        };
+        try {
+            const rec = await getFormDataRecord(host, jd.formId, dataId, jd.objId, '');
+            for (const d of rec.dataDetails || []) {
+                const dk = rev[String(d.fieldId ?? d.formField?.id)] || '';
+                if (!dk)
+                    continue;
+                let v = '';
+                if (Array.isArray(d.dataOptions) && d.dataOptions.length)
+                    v = d.dataOptions.map((o) => o?.content || '').join(',');
+                else if (d.dataText?.content)
+                    v = String(d.dataText.content);
+                else if (d.content !== undefined && d.content !== '')
+                    v = String(d.content);
+                if (v === '')
+                    continue;
+                if (REF_DETAIL_KEYS.includes(dk))
+                    item[dk] = v.slice(0, 60);
+                else if (REF_TEXT_KEYS.includes(dk))
+                    item[dk] = v.replace(/\s+/g, ' ').slice(0, 150);
+            }
+        }
+        catch { /* 单条详情失败不影响其余参考 */ }
+        if (Object.keys(item).length > 3)
+            picked.push(item);
+    }
+    return { available: true, keyword: kw, scanned: rows.length, items: picked };
+}
+async function buildJd(opts) {
+    const { ctx, positionName, duty, requestText, demandId, demandName, sets } = opts;
+    const { host, appId, cache } = ctx;
+    const objId = objIdOf(cache, 'position_manage');
+    const formId = formIdOf(cache, 'position_manage');
+    const fields = cache.fields[objId] || {};
+    const fid = (k) => fields[k];
+    for (const k of DATAKEYS_TEXT)
+        if (!fid(k))
+            throw rsFail('职位管理缺少字段 ' + k + '（ds/fields 解析不到）');
+    for (const k of DATAKEYS_MTEXT)
+        if (!fid(k))
+            throw rsFail('职位管理缺少字段 ' + k + '（ds/fields 解析不到）');
+    const refByFid = await fetchRefByFid(ctx);
+    const map = new Map();
+    const put = (d) => { if (d && d.formField && d.formField.id)
+        map.set(String(d.formField.id), d); };
+    const hasKey = (k) => { const id = fid(k); return !!(id && map.has(String(id))); };
+    // ① 用户提供的核心字段
+    put({ formField: { id: fid('position_name') }, content: positionName });
+    if (duty)
+        put({ formField: { id: fid('position_duty') }, dataText: { content: duty } });
+    if (requestText)
+        put({ formField: { id: fid('work_request') }, dataText: { content: requestText } });
+    if (demandId) {
+        if (!fid('demand'))
+            throw rsFail('职位管理缺少字段 demand（ds/fields 解析不到，关联需求无法设置）');
+        put({ formField: { id: fid('demand') }, dataOptions: [{ optionId: String(demandId), content: demandName || String(demandId) }] });
+    }
+    // ② sets 覆盖（AI 依 JD 指定；优先于自动默认值）
+    const appliedSets = [];
+    const skippedSets = [];
+    for (const [k, v] of sets) {
+        const d = await resolveSetValue(ctx, k, v, refByFid);
+        if (d) {
+            put(d);
+            appliedSets.push(k + '=' + v);
+        }
+        else {
+            skippedSets.push(k + '=' + v);
+        }
+    }
+    // ③ 默认值：招聘状态 = 招聘中
+    if (!hasKey('status')) {
+        if (!fid('status'))
+            throw rsFail('职位管理缺少字段 status（ds/fields 解析不到）');
+        const statusMap = cachedDsMap(cache, objId, 'status') || await getDsOptions(host, objId, fid('status'), appId);
+        const statusId = statusMap[DEF_STATUS];
+        if (!statusId)
+            throw rsFail('职位管理「招聘状态」未解析到「' + DEF_STATUS + '」选项（ds/options 返回为空）');
+        put({ formField: { id: fid('status') }, dataOptions: [{ optionId: String(statusId), content: DEF_STATUS }] });
+    }
+    // ④ 默认值：招聘流程 = 环境默认启用的流程
+    const defFlow = cache.defaultRecruitFlow;
+    if (!hasKey('recruit_flow') && fid('recruit_flow') && defFlow && defFlow.id) {
+        put({ formField: { id: fid('recruit_flow') }, dataOptions: [{ optionId: String(defFlow.id), content: defFlow.name }] });
+    }
+    // ⑤ 人员型默认 = 当前登录用户
+    const filled = [];
+    let currentUser = null;
+    if (DEF_CURRENT_USER.some((k) => fid(k) && !hasKey(k))) {
+        currentUser = await resolveCurrentUser(host);
+        if (currentUser && currentUser.id) {
+            for (const k of DEF_CURRENT_USER) {
+                if (fid(k) && !hasKey(k)) {
+                    put({ formField: { id: fid(k) }, dataOptions: [{ optionId: String(currentUser.id), content: currentUser.name }] });
+                    filled.push(k);
+                }
+            }
+        }
+    }
+    // ⑥ 其余必填字段默认值
+    for (const [k, v] of Object.entries(DEF_TEXT)) {
+        if (fid(k) && !hasKey(k)) {
+            put({ formField: { id: fid(k) }, content: v });
+            filled.push(k);
+        }
+    }
+    for (const [k, name] of Object.entries(DEF_OPTION)) {
+        if (fid(k) && !hasKey(k)) {
+            const m = cachedDsMap(cache, objId, k) || await getDsOptions(host, objId, fid(k), appId);
+            const oid = m[name];
+            if (oid) {
+                put({ formField: { id: fid(k) }, dataOptions: [{ optionId: String(oid), content: name }] });
+                filled.push(k);
+            }
+        }
+    }
+    for (const k of DEF_FROM_REF) {
+        const id = fid(k);
+        if (id && !map.has(String(id)) && refByFid[String(id)]) {
+            const d = refToSubmit(refByFid[String(id)]);
+            if (d) {
+                put(d);
+                filled.push(k);
+            }
+        }
+    }
+    const inv = {};
+    for (const [k, v] of Object.entries(fields))
+        inv[String(v)] = k;
+    const requiredDefaultsFilled = [...map.keys()].map((f) => inv[f] || f).filter((k) => filled.includes(k));
+    return {
+        objId, formId, appId, dataDetails: [...map.values()],
+        summary: {
+            action: '生成职位JD（创建职位）',
+            positionName,
+            dutyLen: (duty || '').length,
+            requestLen: (requestText || '').length,
+            demand: demandId ? (demandName || demandId) : '（未关联需求）',
+            status: DEF_STATUS,
+            recruitFlow: (defFlow && defFlow.id) ? defFlow.name : '（未解析到默认流程）',
+            currentUser: currentUser ? currentUser.name : null,
+            setApplied: appliedSets,
+            setSkipped: skippedSets,
+            requiredDefaultsFilled,
+        },
+    };
+}
+function setsOf(args) {
+    const raw = args.sets;
+    if (Array.isArray(raw)) {
+        return raw.map((item) => {
+            if (typeof item === 'string') {
+                const j = item.indexOf('=');
+                if (j <= 0)
+                    throw rsValidationError('set_invalid', `sets 项必须是 "字段=值" 形式：${item}`);
+                return [item.slice(0, j).trim().replace(/-/g, '_'), item.slice(j + 1)];
+            }
+            if (item && typeof item === 'object' && item.key !== undefined) {
+                return [String(item.key).trim().replace(/-/g, '_'), String(item.value ?? '')];
+            }
+            throw rsValidationError('set_invalid', 'sets 项必须是字符串 "字段=值" 或 {key,value} 对象');
+        });
+    }
+    return [];
+}
+async function prepare(args, env) {
+    const host = env.host;
+    const session = await host.getSession();
+    const ctx = { host, baseUrl: session.baseUrl.replace(/\/+$/, ''), appId: '', cache: await env.recruitContext() };
+    ctx.appId = ctx.cache.appId;
+    const positionName = String(args.positionName || '').trim();
+    if (!positionName)
+        throw rsValidationError('position_name_required', 'positionName 必填');
+    const jd = await buildJd({
+        ctx, positionName,
+        duty: args.positionDuty ? String(args.positionDuty) : undefined,
+        requestText: args.workRequest ? String(args.workRequest) : undefined,
+        demandId: args.demandId ? String(args.demandId) : undefined,
+        demandName: args.demandName ? String(args.demandName) : undefined,
+        sets: setsOf(args),
+    });
+    const refs = await fetchRecentReferences(ctx, jd, String(args.referenceKeyword || positionName))
+        .catch((e) => ({ available: false, reason: e.message, items: [] }));
+    const willSubmit = { formId: jd.formId, objId: jd.objId, dataDetails: jd.dataDetails };
+    const fp = fingerprint(willSubmit);
+    const continuation = await env.continuation.issue({ operation: 'recruit-stage.jd.create.apply', fingerprint: fp });
+    return rsSuccess('recruit-stage.jd.create.prepare', {
+        mode: 'prepare',
+        ...jd.summary,
+        recentReferences: refs.items,
+        recentReferencesNote: refs.available
+            ? `已按「${refs.keyword}」在当前环境职位列表中检索（扫描 ${refs.scanned} 条，命中 ${refs.items.length} 条）——请对标这些同类职位的薪酬/人数/要求给出推荐值，一并放进确认摘要，不要逐字段询问用户`
+            : ('参考检索不可用：' + (refs.reason || '')),
+        willSubmit,
+    }, {
+        continuation,
+        fingerprint: fp,
+        confirmHint: '用户明确确认后，携带 confirm:true 与本 continuation 调用 recruit-stage.jd.create.apply',
+    });
+}
+async function apply(args, env) {
+    if (args.confirm !== true)
+        throw rsConfirmationError('recruit-stage.jd.create.apply', { hint: '写操作必须显式 confirm:true' });
+    if (!args.continuation)
+        throw rsValidationError('continuation_required', '缺少 continuation（来自 prepare 的 meta）');
+    const payload = await env.continuation.verify(String(args.continuation), 'recruit-stage.jd.create.apply');
+    const host = env.host;
+    const session = await host.getSession();
+    const ctx = { host, baseUrl: session.baseUrl.replace(/\/+$/, ''), appId: '', cache: await env.recruitContext() };
+    ctx.appId = ctx.cache.appId;
+    const positionName = String(args.positionName || '').trim();
+    if (!positionName)
+        throw rsValidationError('position_name_required', 'positionName 必填');
+    const jd = await buildJd({
+        ctx, positionName,
+        duty: args.positionDuty ? String(args.positionDuty) : undefined,
+        requestText: args.workRequest ? String(args.workRequest) : undefined,
+        demandId: args.demandId ? String(args.demandId) : undefined,
+        demandName: args.demandName ? String(args.demandName) : undefined,
+        sets: setsOf(args),
+    });
+    const willSubmit = { formId: jd.formId, objId: jd.objId, dataDetails: jd.dataDetails };
+    if (payload.fingerprint !== fingerprint(willSubmit)) {
+        throw rsValidationError('fingerprint_mismatch', '待提交内容与 prepare 确认摘要不一致（字段值已变化），请重新 prepare 确认后再 apply');
+    }
+    // ① 保存职位管理表单 → ② addPosition 提交生成职位
+    const formDataId = await saveFormData(host, {
+        appId: jd.appId, formId: jd.formId, objId: jd.objId,
+        name: '职位管理-' + positionName, dataDetails: jd.dataDetails,
+    });
+    const r2 = await host.request({ path: '/api/recruit/position/v2/addPosition?formDataId=' + formDataId, method: 'POST' });
+    const data = r2?.data || {};
+    const positionPostId = data.positionPostId;
+    const checkRpa = data.checkRpa;
+    const rpaValidMsg = data.rpaValidMsg || null;
+    const created = r2?.status !== false && !!positionPostId;
+    const listUrl = await resolvePositionNewUrl(ctx).catch(() => null);
+    const cardUrl = buildCardUrl(ctx.baseUrl, jd.objId, formDataId);
+    const locateUrl = buildListLocateUrl(ctx.baseUrl, ctx.appId, (ctx.cache.lists?.position?.listId) || '', jd.objId, formDataId);
+    return rsSuccess('recruit-stage.jd.create.apply', {
+        mode: 'apply',
+        result: created ? 'success' : 'failed',
+        formDataId,
+        positionPostId: positionPostId || null,
+        rpaChecked: checkRpa === undefined ? null : !!checkRpa,
+        rpaValidMsg,
+        positionListUrl: listUrl || null,
+        positionCardUrl: cardUrl,
+        positionListLocateUrl: locateUrl,
+        // 产物链接（Agent 原样搬运成 Markdown 链接，按顺序：详情在前、列表在后）
+        viewLink: cardUrl ? `[查看 ${jd.summary.positionName || '新建职位'} 职位详情](${cardUrl})` : null,
+        listLocateLink: (locateUrl || listUrl) ? `[打开招聘岗位列表（已定位新建职位）](${locateUrl || listUrl})` : null,
+        agentNote: '查看入口 = 两个 Markdown 链接（平台实证可点击）：按顺序原样搬运 viewLink 与 listLocateLink；不要包 browsertool 标签。链接只是查看入口，重复点击不会重复创建。',
+        ...jd.summary,
+    });
+}
+async function prefill(args, env) {
+    const host = env.host;
+    const session = await host.getSession();
+    const ctx = { host, baseUrl: session.baseUrl.replace(/\/+$/, ''), appId: '', cache: await env.recruitContext() };
+    ctx.appId = ctx.cache.appId;
+    const positionName = String(args.positionName || '').trim();
+    if (!positionName)
+        throw rsValidationError('position_name_required', 'positionName 必填');
+    const jd = await buildJd({
+        ctx, positionName,
+        duty: args.positionDuty ? String(args.positionDuty) : undefined,
+        requestText: args.workRequest ? String(args.workRequest) : undefined,
+        demandId: args.demandId ? String(args.demandId) : undefined,
+        demandName: args.demandName ? String(args.demandName) : undefined,
+        sets: setsOf(args),
+    });
+    const fields = toPrefillFields(jd.dataDetails, ctx.cache.fields[jd.objId] || {});
+    const listUrl = await resolvePositionNewUrl(ctx);
+    const homeUrl = await resolveHomePageUrl(ctx);
+    const jsExpr = `(() => { const W = window.WeFormSDK; const i = W && W.getWeFormInstance('ebuilderform', '${jd.formId}');`
+        + ` if (!i) return 'no-form-instance(请先打开职位管理新建表单)'; const fields = ${JSON.stringify(fields)};`
+        + ` let ok = 0, fail = []; for (const f of fields) { try { i.changeFieldValue(f.mark, f.info); ok++; } catch (e) { fail.push(f.label); } }`
+        + ` return 'prefilled ' + ok + '/' + fields.length + (fail.length ? ' fail=' + fail.join(',') : ''); })()`;
+    return rsSuccess('recruit-stage.jd.create.prefill', {
+        mode: 'prefill',
+        ...jd.summary,
+        formId: jd.formId,
+        fields,
+        jsExpr,
+        openMethods: {
+            homeFullscreen: { url: homeUrl, openAction: '点「快速入口 → 创建职位」打开表单，再点表单右上角「放大」按钮 → 全屏单页' },
+            listDialog: { url: listUrl, openAction: '点击页面上的「新建」' },
+        },
+        steps: [
+            '1) 浏览器打开 openMethods.homeFullscreen.url（或 listDialog.url），需已登录该环境',
+            '2) 打开新建表单：B = 首页点「创建职位」+ 点表单右上「放大」（全屏单页）；A = 列表点「新建」（弹窗）',
+            '3) 在页面上下文执行 jsExpr（如 browser-skill: bsk evaluate "<jsExpr>"）→ 返回 prefilled N/N 即完成',
+            '4) 由操作者核对内容后自行点「保存/保存并发布」；本模式不写任何数据',
+        ],
+    });
+}
+const baseInput = {
+    positionName: { type: 'string', description: '职位名称（必填）' },
+    positionDuty: { type: 'string', description: '职位职责/JD 正文（多行文本）' },
+    workRequest: { type: 'string', description: '任职要求（多行文本）' },
+    demandId: { ...SCHEMA_ID_STR, description: '关联招聘需求 id（可选）' },
+    demandName: { type: 'string', description: '关联招聘需求名称（可选，仅展示）' },
+    sets: {
+        type: 'array', maxItems: 30,
+        items: { oneOf: [{ type: 'string' }, { type: 'object', properties: { key: { type: 'string' }, value: { type: 'string' } } }] },
+        description: 'AI 依 JD 指定的字段值（"字段dataKey=值" 或 {key,value}）',
+    },
+    referenceKeyword: { type: 'string', description: '同类职位参考检索关键词（默认用职位名）' },
+};
+export const jdCreateOperations = [
+    {
+        name: 'recruit-stage.jd.create.prepare',
+        resource: 'recruit.jd',
+        method: 'prepare',
+        action: 'jd.create.prepare',
+        summary: '生成职位确认摘要：解析职位表单字段、套用默认值（状态/流程/负责人/关联字段取环境现成值）、检索最近同类职位参考，不写入任何数据',
+        capability: 'recruit.jd.create',
+        risk: 'write',
+        requiresConfirmation: true,
+        inputSchema: schemaOf(baseInput, { required: ['positionName'] }),
+        handler: prepare,
+    },
+    {
+        name: 'recruit-stage.jd.create.apply',
+        resource: 'recruit.jd',
+        method: 'apply',
+        action: 'jd.create.apply',
+        summary: '用户确认后创建职位：saveFormData（职位管理）→ addPosition 生成职位，与页面「保存」等价；返回职位详情与列表定位双链接',
+        capability: 'recruit.jd.create',
+        risk: 'write',
+        requiresConfirmation: true,
+        inputSchema: schemaOf({ ...baseInput, confirm: { type: 'boolean', description: '必须显式 true' }, continuation: { type: 'string', description: 'prepare 返回的 continuation' } }, { required: ['positionName', 'confirm', 'continuation'] }),
+        handler: apply,
+    },
+    {
+        name: 'recruit-stage.jd.create.prefill',
+        resource: 'recruit.jd',
+        method: 'prefill',
+        action: 'jd.create.prefill',
+        summary: '预填模式（人工保存）：输出打开职位新建页的 URL + WeFormSDK 注入 jsExpr，不落库，由操作者核对后自行保存',
+        capability: 'recruit.jd.create',
+        risk: 'read',
+        inputSchema: schemaOf(baseInput, { required: ['positionName'] }),
+        handler: prefill,
+    },
+];
+// 保留引用避免 tree-shake 误删（readFileSync/fileURLToPath 供 school-tiers 等后续扩展使用）
+void readFileSync;
+void resolvePath;
+void dirname;
+void fileURLToPath;
+void randomBytes;