openyida 2026.10.21 → 2026.10.22

package/lib/feedback/github-setup.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const { t } = require('../core/i18n');
+
+const INSTALL_URL = 'https://github.com/cli/cli#installation';
+const LOGIN_COMMAND = 'gh auth login --hostname github.com --web --skip-ssh-key';
+
+/** Fixed argv only. Capture diagnostics privately, including package-manager failures. */
+function invoke(binary, args, options, installing = false) {
+  try {
+    return (options.spawnSyncFn || spawnSync)(binary, args, {
+      shell: false, encoding: 'utf8', timeout: installing ? 300000 : 15000,
+      maxBuffer: 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
+      env: { ...(options.env || process.env), GH_HOST: 'github.com', GH_PROMPT_DISABLED: '1',
+        GIT_TERMINAL_PROMPT: '0', HOMEBREW_NO_AUTO_UPDATE: '1', HOMEBREW_NO_INSTALL_CLEANUP: '1',
+        HOMEBREW_NO_INSTALL_UPGRADE: '1', HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: '1', HOMEBREW_NO_SUDO: '1',
+        ...(installing ? { HOMEBREW_NO_ASK: '1' } : {}) },
+    });
+  } catch { return { status: null }; }
+}
+
+function toolState(options) {
+  const result = invoke('gh', ['--version'], options);
+  if (result.error?.code === 'ENOENT') { return { state: 'missing', version: null }; }
+  const version = String(result.stdout || '').match(/^gh version (\d+\.\d+\.\d+)\b/)?.[1];
+  return result.status === 0 && !result.error && version
+    ? { state: 'available', version } : { state: 'unverified', version: null };
+}
+
+function installPlan(options) {
+  const platform = options.platform || process.platform;
+  const binary = platform === 'win32' ? 'winget' : ['darwin', 'linux'].includes(platform) ? 'brew' : null;
+  if (!binary) { return { available: false, reason: 'unsupported_platform', url: INSTALL_URL }; }
+  const probe = invoke(binary, ['--version'], options);
+  if (probe.error || probe.status !== 0) {
+    return { available: false, reason: probe.error?.code === 'ENOENT' ? 'manager_missing' : 'manager_unverified', url: INSTALL_URL };
+  }
+  const args = binary === 'brew' ? ['install', 'homebrew/core/gh']
+    : ['install', '--id', 'GitHub.cli', '--exact', '--source', 'winget', '--no-upgrade', '--disable-interactivity',
+      '--accept-source-agreements', '--accept-package-agreements'];
+  return { available: true, binary, args, url: INSTALL_URL, requiresConsent: true };
+}
+
+function accountState(options) {
+  const result = invoke('gh', ['api', '--hostname', 'github.com', '--method', 'GET', 'user'], options);
+  if (result.status === 4 && !result.error) { return { state: 'login_required', login: null }; }
+  let account;
+  try { account = JSON.parse(result.stdout); } catch { /* Unknown response stays unverified. */ }
+  if (result.status === 0 && !result.error && account?.type === 'User'
+    && /^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(account.login || '')) {
+    return { state: 'verified', login: account.login };
+  }
+  return { state: 'unverified', login: null };
+}
+
+/** Called only after the router validates consent and the managed-run boundary. */
+function setup(parsed, options) {
+  let tool = toolState(options);
+  const installation = { attempted: false, state: 'not_requested', plan: null };
+  if (tool.state === 'missing') {
+    installation.plan = installPlan(options);
+    if (parsed.install) {
+      installation.state = 'unavailable';
+      if (installation.plan.available) {
+        installation.attempted = true;
+        const result = invoke(installation.plan.binary, installation.plan.args, options, true);
+        tool = toolState(options);
+        installation.state = result.status === 0 && !result.error && tool.state === 'available'
+          ? 'verified' : 'unverified';
+      }
+    }
+  } else if (parsed.install) {
+    installation.state = tool.state === 'available' ? 'already_available' : 'unavailable';
+  }
+  const account = tool.state === 'available' ? accountState(options) : { state: 'not_checked', login: null };
+  const ready = tool.state === 'available' && account.state === 'verified';
+  const nextStep = installation.state === 'unverified' ? 'inspect_installation'
+    : tool.state === 'unverified' ? 'check_execution'
+      : tool.state === 'missing' ? (installation.plan?.available ? 'confirm_install' : 'manual_install')
+        : ready ? 'ready' : account.state === 'login_required' ? 'browser_login' : 'check_account';
+  return {
+    success: !parsed.install || ['verified', 'already_available'].includes(installation.state),
+    action: 'setup', tool, account, ready, installation, nextStep,
+    message: t(`feedback_github.setup_${nextStep}`),
+    consentNotice: t('feedback_github.setup_consent'),
+    privacyNotice: t('feedback_github.setup_privacy'),
+    authorization: { performed: false, requiresSeparateConsent: true,
+      command: tool.state === 'available' && !ready ? LOGIN_COMMAND : null,
+      url: 'https://cli.github.com/manual/gh_auth_login' },
+    links: { install: INSTALL_URL, signup: 'https://github.com/signup', issue: 'https://github.com/openyida/openyida/issues/new' },
+    submissionPerformed: false, publicConfirmationRequired: true,
+    inspectBeforeRetry: installation.state === 'unverified',
+  };
+}
+
+module.exports = { setup };

package/lib/feedback/github.js

@@ -11,15 +11,18 @@ const links = Object.freeze({ repository: `https://github.com/${REPOSITORY}`,
 /** Parse explicit account actions; submitting an Issue never implies Star or Fork consent. */
 function parseArgs(args = []) {
   const [action, ...flags] = args;
-  if (!['status', 'star', 'fork'].includes(action) || new Set(flags).size !== flags.length
-    || flags.some(flag => !['--json', '--confirm'].includes(flag))
-    || (action === 'status' && flags.includes('--confirm'))) {
+  const install = flags.includes('--install');
+  if (!['status', 'star', 'fork', 'setup'].includes(action) || new Set(flags).size !== flags.length
+    || flags.some(flag => !['--json', '--confirm', '--install'].includes(flag))
+    || (install && action !== 'setup')
+    || (action === 'status' && flags.includes('--confirm'))
+    || (action === 'setup' && !install && flags.includes('--confirm'))) {
     throw new CliError(t('feedback_github.usage'), { code: 'FEEDBACK_GITHUB_USAGE' });
   }
-  if (action !== 'status' && !flags.includes('--confirm')) {
-    throw new CliError(t('feedback_github.confirmation'), { code: 'FEEDBACK_GITHUB_CONFIRMATION_REQUIRED' });
+  if ((['star', 'fork'].includes(action) || install) && !flags.includes('--confirm')) {
+    throw new CliError(t(install ? 'feedback_github.setup_consent' : 'feedback_github.confirmation'), { code: 'FEEDBACK_GITHUB_CONFIRMATION_REQUIRED' });
   }
-  return { action, confirm: flags.includes('--confirm') };
+  return { action, confirm: flags.includes('--confirm'), ...(action === 'setup' ? { install } : {}) };
 }
 
 /** Run gh against github.com only. Never expose its raw output or credential diagnostics. */
@@ -90,10 +93,12 @@ function inspect(options) {
 
 /** Execute one explicitly authorized action, then read it back. No retry, clone, remote change or Issue submission. */
 function execute(parsed, options = {}) {
-  const { action } = parseArgs([parsed.action, ...(parsed.confirm === true ? ['--confirm'] : [])]);
+  const validated = parseArgs([parsed.action, ...(parsed.confirm === true ? ['--confirm'] : []), ...(parsed.install === true ? ['--install'] : [])]);
+  const { action } = validated;
   if ((options.env || process.env).OPENYIDA_MANAGED_RUN === '1') {
     throw new CliError(t('feedback_github.failed'), { code: 'FEEDBACK_GITHUB_MANAGED_DENIED' });
   }
+  if (action === 'setup') { return require('./github-setup').setup(validated, options); }
   const result = inspect(options);
   if (action === 'status') { return result; }
   const fail = (stage, mutationPerformed = false) => {
@@ -124,7 +129,11 @@ function execute(parsed, options = {}) {
 /** CLI entrypoint. The confirmation flag attests to the user's explicit choice of this action. */
 function run(args = []) {
   const parsed = parseArgs(args);
-  console.log(JSON.stringify(execute(parsed), null, 2));
+  const result = execute(parsed);
+  if (result.success === false) {
+    throw new CliError(result.message, { code: 'FEEDBACK_GITHUB_SETUP_FAILED', details: result });
+  }
+  console.log(JSON.stringify(result, null, 2));
 }
 
 module.exports = { parseArgs, execute, run };

package/lib/feedback/report.js

@@ -13,6 +13,15 @@ const MAX_INPUT_BYTES = 1024 * 1024;
 const REPOSITORY = 'openyida/openyida';
 const TEXT_FIELDS = ['title', 'summary', 'command', 'expected', 'actual', 'impact', 'tool', 'model'];
 const LIST_FIELDS = ['steps', 'evidence', 'attempts'];
+const INCIDENT_FIELDS = ['openyida', 'node', 'platform', 'arch', 'installation', 'browser', 'deployment', 'organizationContext'];
+
+function incidentEnvironment(value) {
+  if (value === undefined) {value = {};}
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {throw invalid('object');}
+  // Only explicit incident facts belong here. The reporting process may run
+  // after an upgrade or on another machine; never infer incident versions.
+  return Object.fromEntries(INCIDENT_FIELDS.map(key => [key, sanitizeText(value[key])]));
+}
 
 function comparisonRun(value) {
   if (value === undefined) {return { status: 'not_run', evidence: [] };}
@@ -98,6 +107,8 @@ function buildReport(input) {
     throw invalid('confirmed');
   }
   report.screenshots = [];
+  report.incidentEnvironment = incidentEnvironment(input.incidentEnvironment);
+  // Retain this output contract for existing consumers: generator context only.
   report.environment = {
     openyida: require('../../package.json').version,
     node: process.version,
@@ -114,17 +125,28 @@ function buildReport(input) {
 
 // Escape markup so copied diagnostics cannot inject images, links or HTML in an issue.
 function markdownText(value) {
-  return String(value || 'Unknown / not verified').replace(/[\\`*_{}[\]<>()#!|~]/g, '\\$&');
+  return String(value || t('feedback_report.body.unknown')).replace(/[\\`*_{}[\]<>()#!|~]/g, '\\$&');
 }
 
 function renderMarkdown(report) {
+  const label = key => t('feedback_report.body.' + key);
+  const incident = report.incidentEnvironment || {};
+  const environmentLines = Object.entries({
+    openyida: incident.openyida, node: incident.node, platform: incident.platform, arch: incident.arch,
+    installation: incident.installation, tool: report.tool, model: report.model,
+    ...Object.fromEntries(['browser', 'deployment', 'organizationContext']
+      .filter(key => incident[key]).map(key => [key, incident[key]])),
+  }).map(([key, value]) => `${key}: ${value || label('unknown')}`);
   const sections = [
-    ['Summary', report.summary], ['Command scenario', report.command],
-    ['Steps to reproduce', report.steps], ['Expected', report.expected], ['Actual', report.actual],
-    ['Impact', report.impact], ['Evidence (observed)', report.evidence], ['Attempts and results', report.attempts],
-    ['Root cause assessment', `${report.cause.category} / ${report.cause.status}\n${report.cause.summary || 'Not established'}`],
-    ['Evidence for assessment', report.cause.evidence], ['Next verification', report.cause.nextSteps],
-    ['Reproduction screenshots', report.screenshots.map(item => `${item.file}: ${item.description || 'Review image before sharing'}`)],
+    [label('summary'), report.summary || label('unknown')],
+    [label('actual'), report.actual], [label('expected'), report.expected || label('unknown')],
+    [label('incident'), environmentLines],
+    [label('command'), report.command], [label('steps'), report.steps],
+    [label('impact'), report.impact], [label('evidence'), report.evidence], [label('attempts'), report.attempts],
+    ...(report.cause.summary || report.cause.status !== 'unknown' || report.cause.category !== 'unknown'
+      ? [[label('cause'), `${report.cause.category} / ${report.cause.status}\n${report.cause.summary}`]] : []),
+    [label('cause_evidence'), report.cause.evidence], [label('next'), report.cause.nextSteps],
+    [label('screenshots'), report.screenshots.map(item => `${item.file}: ${item.description || label('review_image')}`)],
     ...(['before', 'after', 'regression'].some(key => report.comparison[key].status !== 'not_run') || report.comparison.limitations.length ? ['before', 'after', 'regression'] : []).map(key => [
       `Test comparison: ${key}`, [
         `Status: ${report.comparison[key].status}`,
@@ -134,19 +156,17 @@ function renderMarkdown(report) {
         ...(report.comparison[key].evidence || []),
       ],
     ]),
-    ...(report.comparison.limitations.length ? [['Test limitations', report.comparison.limitations]] : []),
-  ];
+    ...(report.comparison.limitations.length ? [[label('limitations'), report.comparison.limitations]] : []),
+    [label('generator'), Object.entries(report.environment).map(([key, value]) => `${key}: ${value}`)],
+  ].filter(([, value]) => Array.isArray(value) ? value.length : Boolean(value));
   return [
     `# ${markdownText(report.title)}`, '',
-    'Local draft — not submitted. Review business data and private repository information before sharing.', '',
-    `Fingerprint: ${report.fingerprint}`, `Observed occurrences: ${report.occurrenceCount || 'Unknown'}`, '',
-    '## Environment', '',
-    ...Object.entries({ ...report.environment, tool: report.tool, model: report.model })
-      .map(([key, value]) => `- ${key}: ${markdownText(value)}`), '',
+    label('draft'), '',
     ...sections.flatMap(([heading, value]) => [
       `## ${heading}`, '',
-      Array.isArray(value) ? (value.length ? value.map(item => `- ${markdownText(item)}`).join('\n') : 'Unknown / not verified') : markdownText(value), '',
+      Array.isArray(value) ? value.map(item => `- ${markdownText(item)}`).join('\n') : markdownText(value), '',
     ]),
+    `Fingerprint: ${report.fingerprint}`, `Observed occurrences: ${report.occurrenceCount || label('unknown')}`, '',
   ].join('\n');
 }
 

package/lib/integration/integration-triggers.js

@@ -18,11 +18,16 @@ function scheduleNodes(schedule, id, nextId) {
   if (!/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:00$/.test(startDate || '')
     || !Number.isFinite(Date.parse(startDate.replace(' ', 'T') + '+08:00'))
     || !['ONCE', 'DAILY', 'WORKDAY', 'WEEKLY', 'BI_WEEKLY', 'MONTHLY', 'LAST_DAY_PER_MONTH'].includes(repeat)
-    || maxCount !== undefined && (!Number.isInteger(maxCount) || maxCount < 1)
+    || maxCount !== undefined && (!Number.isInteger(maxCount) || maxCount < 1 || maxCount > 100)
     || expireDate !== undefined && (!Number.isFinite(expireDate)
       || expireDate <= Date.parse(startDate.replace(' ', 'T') + '+08:00'))
     || maxCount !== undefined && expireDate !== undefined
     || repeat === 'ONCE' && (maxCount !== undefined || expireDate !== undefined)) { invalid('schedule values'); }
+  if (repeat !== 'ONCE' && maxCount === undefined && expireDate === undefined) {
+    throw new CliError(t('integration_triggers.end_required'), {
+      code: 'INTEGRATION_TRIGGER_INVALID', details: { reason: 'schedule end condition', remoteWrites: 0 },
+    });
+  }
   const startTimestamp = Date.parse(startDate.replace(' ', 'T') + '+08:00');
   if (new Date(startTimestamp + 8 * 3600000).toISOString().slice(0, 19).replace('T', ' ') !== startDate) {
     invalid('invalid calendar date');
@@ -37,8 +42,8 @@ function scheduleNodes(schedule, id, nextId) {
     viewNode: { componentName: 'StartNode', id, props: { nodeName: 'StartNode', name, nodeError: '',
       start: { type: 'trigger', triggerType: 'TimerEvent', startDate: startTimestamp, repeatRuleType: repeat,
         startTrigger: { startTriggerTime: 'specifiedTime' },
-        overTimeType: maxCount !== undefined ? 'count' : expireDate !== undefined ? 'time' : 'never',
-        ...(maxCount !== undefined ? { overCount: maxCount } : {}),
+        overTimeType: expireDate !== undefined ? 'time' : 'count',
+        ...(expireDate === undefined ? { overCount: maxCount ?? 1 } : {}),
         ...(expireDate !== undefined ? { overTime: expireDate } : {}), rules: true } } },
     formEventTypes: [],
   };

package/lib/process/configure-process.js

@@ -19,6 +19,7 @@ const {
 } = require('./services/process-compiler');
 const { verifyPlatformView } = require('./services/process-view-verifier');
 const { inspectProcessFields, assertPermissionFields } = require('./services/process-form-fields');
+const { collectFormMemberIds, assertFormMemberFields } = require('./services/process-dynamic-actors');
 const { completeSubtablePermissions } = require('./services/process-field-permissions');
 const {
   getProcessById,
@@ -365,6 +366,7 @@ async function run(args, options) {
       'build_definition',
       error,
       {
+        ...(error.code === 'PROCESS_DYNAMIC_ACTOR_INVALID' ? error.details : {}),
         retryable: false,
         nextAction: 'fix_definition_file',
         diagnostics: [summarizeRemoteResult(error)],
@@ -417,13 +419,17 @@ async function run(args, options) {
   }
   stageTracker.complete('preflight_form_mode');
 
-  if (Object.keys(compiled.processJson.flowConfig).length) {
+  const memberFieldIds = collectFormMemberIds(compiled.viewJson);
+  if (Object.keys(compiled.processJson.flowConfig).length || memberFieldIds.length) {
     try {
       const fieldInspection = await inspectProcessFields(authRef, { appType, formUuid, processCode }, { binding: initialMode });
       assertPermissionFields(compiled.processJson.flowConfig, fieldInspection.fields);
+      assertFormMemberFields(memberFieldIds, fieldInspection.fields);
       completeSubtablePermissions(compiled, fieldInspection.fields);
     } catch (error) {
-      failure(error.code || 'PROCESS_FORM_FIELDS_READ_FAILED', error.message, 'preflight_form_fields', error, { remoteWrites: 0 });
+      failure(error.code || 'PROCESS_FORM_FIELDS_READ_FAILED', error.message, 'preflight_form_fields', error, {
+        ...(error.code === 'PROCESS_DYNAMIC_ACTOR_INVALID' ? error.details : {}), remoteWrites: 0,
+      });
     }
   }
 

package/lib/process/process-tasks.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const { CliError } = require('../core/cli-error');
+const { t } = require('../core/i18n');
+
+function fail(code, key, details = {}) {
+  throw new CliError(t(`process_tasks.${key}`), {
+    code,
+    details: { retryable: false, retrySafe: true, sideEffectState: 'none', ...details },
+  });
+}
+
+function taskId(value) {
+  if (typeof value === 'number' && (!Number.isSafeInteger(value) || value <= 0)) {return null;}
+  const id = typeof value === 'number' ? String(value) : value;
+  return typeof id === 'string' && /^[1-9][0-9]*$/.test(id) ? id : null;
+}
+
+function validateArguments(positionals, options, transfer = false) {
+  const required = ['process_inst_id', ...(transfer
+    ? ['to_user_id', 'form_uuid', 'expect_form_name', 'expect_form_type'] : [])];
+  const allowed = [...required, 'json', ...(transfer ? ['task_id', 'remark'] : [])];
+  if (positionals.length !== 1 || !/^APP_[A-Za-z0-9_-]+$/.test(positionals[0])) {
+    fail('DATA_INVALID_ARGUMENTS', 'arguments_invalid');
+  }
+  if (Object.keys(options).some(key => !allowed.includes(key))
+    || required.some(key => typeof options[key] !== 'string' || !options[key].trim())
+    || (options.remark !== undefined && (typeof options.remark !== 'string' || !options.remark.trim()))
+    || !/^[A-Za-z0-9_-]+$/.test(options.process_inst_id)
+    || (transfer && !/^FORM[-_][A-Za-z0-9_-]+$/.test(options.form_uuid))
+    || ['process_inst_id', 'form_uuid', 'to_user_id'].some(key =>
+      typeof options[key] === 'string' && /\s/.test(options[key]))
+    || (options.task_id !== undefined && !taskId(options.task_id))) {
+    fail('DATA_INVALID_ARGUMENTS', 'arguments_invalid');
+  }
+}
+
+function successful(response) {
+  return response && response.success === true && !response.__needLogin && !response.__csrfExpired
+    && [undefined, null, '', 0, '0'].includes(response.errorCode);
+}
+
+async function queryProcessTasks(client, appType, processInstanceId) {
+  const response = await client.get(
+    `/dingtalk/web/${appType}/query/formProcInstData/getInstTaskDatas.json`,
+    {
+      _api: 'DataManage.getInstTasks', _mock: 'false', _stamp: String(Date.now()),
+      _locale_time_zone_offset: '28800000', procInstId: processInstanceId,
+    }
+  );
+  if (!successful(response)) {
+    fail('DATA_PROCESS_TASK_QUERY_FAILED', 'query_failed', {
+      causeCode: response && response.errorCode,
+    });
+  }
+  if (!Array.isArray(response.content)) {
+    fail('DATA_PROCESS_TASK_RESPONSE_INVALID', 'response_invalid');
+  }
+  const ids = new Set();
+  const tasks = response.content.map(task => {
+    const id = task && taskId(task.id);
+    if (!id || task.processInstanceId !== processInstanceId || ids.has(id)
+      || typeof task.status !== 'string' || !task.status) {
+      fail('DATA_PROCESS_TASK_RESPONSE_INVALID', 'response_invalid');
+    }
+    ids.add(id);
+    return { ...task, taskId: id };
+  });
+  return { ...response, content: tasks };
+}
+
+function selectTask(tasks, requestedId) {
+  const running = tasks.filter(task => task.status === 'RUNNING');
+  if (requestedId !== undefined) {
+    const selected = running.find(task => task.taskId === requestedId);
+    if (!selected) {fail('DATA_PROCESS_TASK_NOT_RUNNING', 'not_running', { taskId: requestedId });}
+    return selected;
+  }
+  if (!running.length) {fail('DATA_PROCESS_TASK_NOT_RUNNING', 'not_running');}
+  if (running.length !== 1) {
+    fail('DATA_PROCESS_TASK_AMBIGUOUS', 'ambiguous', {
+      tasks: running.map(task => ({ taskId: task.taskId, groupName: task.groupName,
+        activityCode: task.activityCode, actualActionerId: task.actualActionerId })),
+    });
+  }
+  return running[0];
+}
+
+function verifiedTask(before, selected, after, toUserId) {
+  const original = after.find(task => task.taskId === selected.taskId);
+  if (original && original.status === 'RUNNING') {
+    return original.actualActionerId === toUserId ? original : null;
+  }
+  // A recipient's existing parallel task is not evidence of this transfer.
+  // Require the old task to close and a uniquely new task in the same node/group.
+  if (!selected.activityCode || !taskId(selected.taskGroupId)) {return null;}
+  const previousIds = new Set(before.map(task => task.taskId));
+  const candidates = after.filter(task => task.status === 'RUNNING'
+    && !previousIds.has(task.taskId)
+    && task.activityCode === selected.activityCode
+    && String(task.taskGroupId) === String(selected.taskGroupId));
+  return candidates.length === 1 && candidates[0].actualActionerId === toUserId ? candidates[0] : null;
+}
+
+async function transferTask(client, input) {
+  const { appType, formUuid, processInstanceId, toUserId, remark = '转交' } = input;
+  const before = (await queryProcessTasks(client, appType, processInstanceId)).content;
+  const selected = selectTask(before, input.taskId);
+  if (typeof selected.actualActionerId !== 'string' || !selected.actualActionerId.trim()) {
+    fail('DATA_PROCESS_TASK_RESPONSE_INVALID', 'response_invalid');
+  }
+  const target = { appType, formUuid, processInstanceId, taskId: selected.taskId, toUserId };
+  const nextStep = `openyida data query process-tasks ${appType} --process-inst-id ${processInstanceId} --json`;
+  const result = {
+    ...target, target, previousActionerId: selected.actualActionerId,
+    mutationPerformed: false, mutationAccepted: false, readbackVerified: false,
+  };
+  if (selected.actualActionerId === toUserId) {
+    return { ...result, success: true, status: 'ALREADY_ASSIGNED', alreadyAssigned: true,
+      transferred: false, readbackVerified: true, sideEffectState: 'none' };
+  }
+  let response;
+  try {
+    const query = new URLSearchParams({
+      _api: 'DataManage.redirectTask', _mock: 'false', _stamp: String(Date.now()),
+    });
+    response = await client.postFormOnce(
+      `/dingtalk/web/${appType}/query/instance/redirectTask.json?${query}`,
+      { _locale_time_zone_offset: '28800000', taskId: selected.taskId,
+        procInstId: processInstanceId, nowActionerId: toUserId, remark, byManager: 'true' },
+      { referer: `${client.getAuthRef().baseUrl}/${appType}/admin/${formUuid}/dataManage` }
+    );
+  } catch (error) {
+    fail('DATA_PROCESS_TRANSFER_RESULT_UNKNOWN', 'result_unknown', {
+      ...result, mutationPerformed: true, status: 'RESULT_UNKNOWN', mutationAccepted: null,
+      retrySafe: false, sideEffectState: 'unknown', readbackAllowed: true, nextStep,
+      causeCode: error.code || 'TRANSFER_TRANSPORT_FAILED',
+    });
+  }
+  if (!successful(response)) {
+    const rejected = response && response.success === false && !response.__needLogin
+      && !response.__csrfExpired && !response.__nonJsonResponse;
+    fail(rejected ? 'DATA_PROCESS_TRANSFER_REJECTED' : 'DATA_PROCESS_TRANSFER_RESULT_UNKNOWN',
+      rejected ? 'rejected' : 'result_unknown', {
+        ...result, mutationPerformed: true, mutationAccepted: rejected ? false : null,
+        status: rejected ? 'REJECTED' : 'RESULT_UNKNOWN', retrySafe: false,
+        sideEffectState: rejected ? 'none' : 'unknown', readbackAllowed: true, nextStep,
+        causeCode: response && response.errorCode,
+      });
+  }
+  let verified;
+  try {
+    const after = (await queryProcessTasks(client, appType, processInstanceId)).content;
+    verified = verifiedTask(before, selected, after, toUserId);
+  } catch (error) {
+    fail('DATA_PROCESS_TRANSFER_UNVERIFIED', 'unverified', {
+      ...result, mutationPerformed: true, mutationAccepted: true, status: 'UNVERIFIED',
+      retrySafe: false, sideEffectState: 'unknown', readbackAllowed: true, nextStep,
+      causeCode: error.code || 'TRANSFER_READBACK_FAILED',
+    });
+  }
+  if (!verified) {
+    fail('DATA_PROCESS_TRANSFER_UNVERIFIED', 'unverified', {
+      ...result, mutationPerformed: true, mutationAccepted: true, status: 'UNVERIFIED',
+      retrySafe: false, sideEffectState: 'unknown', readbackAllowed: true, nextStep,
+      causeCode: 'TRANSFER_READBACK_MISMATCH',
+    });
+  }
+  return { ...result, success: true, transferred: true, status: 'TRANSFERRED',
+    mutationPerformed: true, mutationAccepted: true, readbackVerified: true,
+    currentTaskId: verified.taskId, actualActionerId: verified.actualActionerId,
+    retryable: false, sideEffectState: 'committed' };
+}
+
+module.exports = { validateArguments, queryProcessTasks, transferTask };

package/lib/process/services/process-actor-config.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { verifyDynamicActors } = require('./process-dynamic-actors');
+
 // The native MultiApproval setter stores flat UI rules, while runtime rules
 // are grouped by status. Keep the two representations separate.
 function buildMultiApproverRules(config, legacyRules) {
@@ -26,6 +28,7 @@ function verifyActorRoles(expectedNodes, actualNodes, errors) {
   }
   (expectedNodes || []).forEach((node, index) => {
     const actual = (actualNodes || [])[index];
+    verifyDynamicActors(node, actual, errors);
     const expectedConditional = node.props?.approverRules;
     if (expectedConditional?.mode === 'ApprovalNode_rules_multiple'
       && JSON.stringify(expectedConditional) !== JSON.stringify(actual?.props?.approverRules)) {

package/lib/process/services/process-compiler.js

@@ -11,6 +11,7 @@ const { t } = require('../../core/i18n');
 const { buildNodeActions } = require('./process-actions');
 const { buildFlowConfig, normalizeBehaviorList } = require('./process-field-permissions');
 const { buildMultiApproverRules } = require('./process-actor-config');
+const { buildDynamicActor, validateNativeActor, assertNativeActorTypes } = require('./process-dynamic-actors');
 
 const KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/;
 
@@ -369,6 +370,8 @@ function getFriendlyApproverKind(approver) {
   }
   const normalized = rawKind.toLowerCase().replace(/[-_\s]/g, '');
   const kindMap = {
+    formfield: 'formField',
+    selfselect: 'selfSelect',
     originator: 'originator',
     self: 'originator',
     starter: 'originator',
@@ -638,6 +641,11 @@ function buildFriendlyApproverConfig(node, approver) {
     return null;
   }
   const raw = isPlainObject(approver) ? approver : {};
+  if (kind === 'formField' || kind === 'selfSelect') {
+    return buildDynamicActor(node, raw, kind, normalizeNodeType(node), {
+      createBaseApproverRules, normalizeApprovalMode, normalizeUserApprovers, normalizeRoleApprovers,
+    });
+  }
   if (kind === 'originator') {
     return buildOriginatorApproverConfig(node, raw);
   }
@@ -1066,8 +1074,12 @@ function buildApproverConfig(node) {
     return friendlyApprover;
   }
 
+  if (typeof approverInput === 'string') {
+    validateNativeActor({ kind: approverInput }, nodeType);
+  }
   const rawApprover = node.approverConfig || (approverInput && typeof approverInput === 'object' ? approverInput : null);
   if (rawApprover) {
+    validateNativeActor(rawApprover, nodeType, node._nodeId);
     return {
       approvalType: rawApprover.approvalType || rawApprover.type || 'ext_target_approval_originator',
       approvals: rawApprover.approvals || [['originator']],
@@ -1086,6 +1098,7 @@ function buildApproverConfig(node) {
   }
 
   if (node.approvalType || node.approvals || node.approverRules || node.processProps) {
+    validateNativeActor({ ...node, type: node.approvalType }, nodeType, node._nodeId);
     return {
       approvalType: node.approvalType || 'ext_target_approval_originator',
       approvals: node.approvals || [['originator']],
@@ -2053,6 +2066,8 @@ function buildProcessAndViewJson(definition, processCode, formUuid, baseUrl, app
     },
   };
 
+  assertNativeActorTypes(processJson.nodes);
+  assertNativeActorTypes(viewJson.schema.children);
   processJson.flowConfig = buildFlowConfig(viewJson);
   const result = {
     processJson,