openyida 2026.10.21 → 2026.10.22

package/lib/process/services/process-dynamic-actors.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const { CliError } = require('../../core/cli-error');
+const { t } = require('../../core/i18n');
+
+const FORM_MEMBER = 'ext_target_approval_variable';
+const SELF_SELECT = 'ext_target_optional_approval';
+// Native designer ApproverType, plus the existing conditional-actors adapter.
+const NATIVE_TYPES = new Set(['ext_target_noset', 'ext_target_approval', 'ext_target_approval_role',
+  'ext_target_approval_originator', 'ext_target_approval_liaison', 'ext_target_dept_leader',
+  'ext_target_direct_leader', 'ext_target_multi_management', SELF_SELECT, FORM_MEMBER,
+  'ext_target_approval_invoke', 'ext_target_approval_connector', 'ext_target_approval_matrix',
+  'ext_target_approval_condition']);
+
+function invalid(reason, details = {}) {
+  throw new CliError(t('process_dynamic_actors.invalid'), {
+    code: 'PROCESS_DYNAMIC_ACTOR_INVALID', details: { reason, ...details, remoteWrites: 0 },
+  });
+}
+
+function buildDynamicActor(node, input, kind, nodeType, helpers) {
+  const allowed = ['kind', 'type', 'approverType', 'approvalMode', 'multiApproverType', 'description'];
+  allowed.push(...(kind === 'formField' ? ['fieldId', 'fieldIds'] : ['range']));
+  if (Object.keys(input).some(key => !allowed.includes(key))) { invalid('unsupported property'); }
+  if (input.kind && input.type && input.kind !== input.type) { invalid('conflicting kind/type'); }
+  const mode = helpers.normalizeApprovalMode(input.approvalMode || input.multiApproverType || 'all');
+  if (!['all', 'or', 'oneByOne'].includes(mode)) { invalid('approvalMode'); }
+  const approvalType = kind === 'formField' ? FORM_MEMBER : SELF_SELECT;
+  const description = input.description || kind;
+  const approverRules = helpers.createBaseApproverRules(approvalType, description, {});
+  approverRules.multiApproverType = mode;
+  approverRules['approvalType_' + approvalType] = mode;
+  if (kind === 'formField') {
+    if (input.fieldId !== undefined && input.fieldIds !== undefined) { invalid('use fieldId or fieldIds'); }
+    const ids = input.fieldId === undefined ? input.fieldIds : [input.fieldId];
+    if (!Array.isArray(ids) || !ids.length || ids.some(id => typeof id !== 'string' || !id.trim() || id !== id.trim())
+      || new Set(ids).size !== ids.length) { invalid('fieldId/fieldIds'); }
+    approverRules.formMember = ids.map(value => ({ value, label: value }));
+    return { approvalType, approvals: [ids], approverRules, description,
+      processProps: { multiApprove: mode }, carbonReceiver: { type: 'VARIABLE', value: [ids] } };
+  }
+  // Carbon self-selection needs a separate non-free entitlement and feature flag.
+  // MultiApproval deliberately excludes this source in the native designer.
+  if (!['approval', 'operator'].includes(nodeType)) { invalid('selfSelect requires approval/operator', { nodeType }); }
+  const range = input.range === undefined ? { type: 'ALL' } : input.range;
+  if (!range || typeof range !== 'object' || Array.isArray(range)
+    || !['ALL', 'USER', 'ROLE'].includes(range.type)) { invalid('range.type'); }
+  const rangeKey = range.type === 'USER' ? 'users' : range.type === 'ROLE' ? 'roles' : null;
+  if (Object.keys(range).some(key => key !== 'type' && key !== rangeKey)) { invalid('range properties'); }
+  const runtimeRange = { type: range.type };
+  const viewRange = { type: range.type };
+  if (rangeKey) {
+    if (!Array.isArray(range[rangeKey]) || !range[rangeKey].length) { invalid('range must be nonempty'); }
+    let items;
+    try {
+      items = rangeKey === 'users' ? helpers.normalizeUserApprovers({ users: range.users })
+        : helpers.normalizeRoleApprovers({ roles: range.roles });
+    } catch { invalid('range member/role requires a real ID'); }
+    if (items.some(item => !item.id.trim() || !['YIDA', 'DINGTALK'].includes(item.roleType))) { invalid('range ID/roleType'); }
+    if (new Set(items.map(item => String(item.id))).size !== items.length) { invalid('duplicate range ID'); }
+    const key = rangeKey === 'users' ? 'approvalRange' : 'roleRange';
+    viewRange[key] = items;
+    runtimeRange[key] = rangeKey === 'users' ? items.map(item => item.id) : items;
+  }
+  approverRules.approvalOptionalRange = viewRange;
+  return { approvalType, approvals: ['__optionalApproval_' + node._nodeId], approverRules, description,
+    processProps: { multiApprove: mode, optionalApprovalRange: runtimeRange } };
+}
+
+function validateNativeActor(raw, nodeType, nodeId) {
+  if (Array.isArray(raw)) { invalid('actor must be an object'); }
+  if (raw.kind || raw.approverType) { invalid('unknown friendly actor kind', { kind: raw.kind || raw.approverType }); }
+  const type = raw.approvalType || raw.type || 'ext_target_approval_originator';
+  if (!NATIVE_TYPES.has(type)) { invalid('unknown native approvalType', { approvalType: type }); }
+  if (raw.approverRules?.type && raw.approverRules.type !== type) { invalid('runtime/view approvalType mismatch'); }
+  // Dynamic native payloads need both halves. Never default their runtime to originator.
+  if (type === FORM_MEMBER || type === SELF_SELECT) {
+    if (!raw.approvals || !raw.approverRules) { invalid('dynamic native actors require approvals and approverRules'); }
+    if (type === SELF_SELECT && !['approval', 'operator'].includes(nodeType)) {
+      invalid('selfSelect requires approval/operator', { nodeType });
+    }
+    if (type === FORM_MEMBER) {
+      const members = raw.approverRules.formMember;
+      const ids = Array.isArray(members) ? members.map(item => item?.value) : [];
+      if (!ids?.length || ids.some(id => typeof id !== 'string' || !id.trim())
+        || JSON.stringify(raw.approvals) !== JSON.stringify([ids])) { invalid('formMember/runtime mismatch'); }
+      if (nodeType === 'carbon' && (raw.carbonReceiver?.type !== 'VARIABLE'
+        || JSON.stringify(raw.carbonReceiver.value) !== JSON.stringify([ids]))) { invalid('carbonReceiver mismatch'); }
+    } else {
+      const view = raw.approverRules.approvalOptionalRange;
+      const runtime = (raw.processProps || raw.props || {}).optionalApprovalRange;
+      if (!view || !runtime || !['ALL', 'USER', 'ROLE'].includes(view.type) || view.type !== runtime.type
+        || JSON.stringify(raw.approvals) !== JSON.stringify(['__optionalApproval_' + nodeId])) {
+        invalid('selfSelect runtime/view range or generated node ID mismatch');
+      }
+      const key = view.type === 'USER' ? 'approvalRange' : view.type === 'ROLE' ? 'roleRange' : null;
+      if (key) {
+        const members = view[key];
+        if (!Array.isArray(members) || !members.length || members.some(item => !item?.id)) { invalid('selfSelect range IDs'); }
+        const ids = members.map(item => item.id);
+        const runtimeIds = view.type === 'USER' ? runtime[key] : runtime[key]?.map(item => item.id);
+        if (JSON.stringify(ids) !== JSON.stringify(runtimeIds)) { invalid('selfSelect runtime/view range IDs mismatch'); }
+      }
+    }
+  }
+}
+
+// Check both emitted contracts, including legacy multiRules and nested branches.
+function assertNativeActorTypes(value) {
+  if (!value || typeof value !== 'object') { return; }
+  if (Array.isArray(value)) { value.forEach(assertNativeActorTypes); return; }
+  for (const [key, item] of Object.entries(value)) {
+    if (['type', 'approvalType'].includes(key) && typeof item === 'string' && item.startsWith('ext_target_')
+      && item !== 'ext_target_activity' && !NATIVE_TYPES.has(item)) {
+      invalid('unknown native approvalType', { approvalType: item });
+    }
+    if (item && typeof item === 'object') { assertNativeActorTypes(item); }
+  }
+}
+
+function actorRules(node) {
+  const props = node?.props || {};
+  return props.multiApproverRules ? props.multiApproverRules.multiRules || [] : [props.approverRules].filter(Boolean);
+}
+
+function collectFormMemberIds(view) {
+  const ids = new Set();
+  function visit(nodes) {
+    for (const node of nodes || []) {
+      for (const rule of actorRules(node)) {
+        if (rule.type === FORM_MEMBER) { (rule.formMember || []).forEach(item => ids.add(item.value)); }
+      }
+      visit(node.children);
+    }
+  }
+  visit(view?.schema?.children);
+  return [...ids];
+}
+
+function assertFormMemberFields(ids, fields) {
+  for (const fieldId of ids) {
+    const field = fields.find(item => item.fieldId === fieldId);
+    if (!field || field.componentName !== 'EmployeeField' || field.parentFieldId) {
+      invalid('formField requires an existing top-level EmployeeField', { fieldId, componentName: field?.componentName });
+    }
+  }
+}
+
+function verifyDynamicActors(expected, actual, errors) {
+  function signature(node) {
+    return actorRules(node).filter(rule => [FORM_MEMBER, SELF_SELECT].includes(rule.type)).map(rule => {
+      if (rule.type === FORM_MEMBER) { return { type: rule.type, mode: rule['approvalType_' + rule.type], ids: (rule.formMember || []).map(item => item.value) }; }
+      const range = rule.approvalOptionalRange || {};
+      return { type: rule.type, mode: rule['approvalType_' + rule.type], rangeType: range.type,
+        users: range.type === 'USER' ? (range.approvalRange || []).map(item => String(item.id)) : [],
+        roles: range.type === 'ROLE' ? (range.roleRange || []).map(item => ({ id: String(item.id), roleType: item.roleType || 'YIDA' })) : [] };
+    });
+  }
+  const wanted = signature(expected);
+  if (wanted.length && JSON.stringify(wanted) !== JSON.stringify(signature(actual))) {
+    errors.push({ code: 'PROCESS_PLATFORM_VIEW_DYNAMIC_ACTORS_MISMATCH', nodeId: expected.id });
+  }
+}
+
+module.exports = { assertNativeActorTypes, buildDynamicActor, validateNativeActor, collectFormMemberIds, assertFormMemberFields, verifyDynamicActors };

package/lib/samples/openyida-scaffold/canvas-nav/mixed.jsx

@@ -12,7 +12,7 @@ function CanvasNav({ items = [], activeKey, onSelect, title, logo, actions, chil
       .oy-canvas-nav.oy-nav-mixed .oy-nav-sidebar { padding: var(--pod-nav-l-aside-padding, 8px); }
       .oy-nav-mixed .oy-nav-content { flex: 1; }
       .oy-nav-mixed .oy-nav-menu { display: flex; flex-direction: column; gap: var(--pod-nav-menu-gap, 8px); }
-      @media (max-width: 767px) {
+      @container (max-width: 767px) {
         .oy-nav-mixed .oy-nav-groups { flex-basis: 100%; }
         .oy-nav-mixed .oy-nav-body { display: block; }
         .oy-nav-mixed .oy-nav-menu { flex-direction: row; overflow-x: auto; border-right: 0; border-bottom: 1px solid var(--pod-nav-sub-divider-color, var(--color-line1-1, #ddd)); }

package/lib/samples/openyida-scaffold/canvas-nav/shared.jsx

@@ -4,7 +4,7 @@ import React from 'react';
 // 这是可选实现示例；导航外观按 design.md 设计，已有 UI 无需替换成示例默认样式。
 // 选中菜单标识当前页面，main 用 aria-label 命名，children 直接承载业务内容。
 const CANVAS_NAV_CSS = `
-  .oy-canvas-nav { display: flow-root; min-width: 0; min-height: 100vh; background: var(--pod-page-bg-color, var(--color-white, #fff)); }
+  .oy-canvas-nav { container-type: inline-size; display: flow-root; min-width: 0; min-height: 100vh; background: var(--pod-page-bg-color, var(--color-white, #fff)); }
   .oy-canvas-nav .oy-nav-surface {
     background: var(--pod-shell-theme-bg-color, var(--pod-nav-popup-bg-color, var(--color-white, #fff)));
     color: var(--pod-nav-item-text-color, var(--color-text1-4, #1f2329));

package/lib/samples/openyida-scaffold/canvas-nav/side.jsx

@@ -6,7 +6,7 @@ function CanvasNav({ items = [], activeKey, onSelect, title, logo, actions, chil
       .oy-nav-side .oy-nav-content { flex: 1; }
       .oy-nav-side .oy-nav-brand { min-height: var(--pod-nav-platform-header-height, 48px); }
       .oy-nav-side .oy-nav-menu { display: flex; flex-direction: column; gap: var(--pod-nav-menu-gap, 8px); }
-      @media (max-width: 767px) { .oy-nav-side { display: block; } }
+      @container (max-width: 767px) { .oy-nav-side { display: block; } }
     `}</style>
     <CanvasSidebar title={title} logo={logo} actions={actions} activeKey={activeKey} defaultWidth={sidebarWidth} defaultCollapsed={defaultCollapsed}>
       <nav aria-label="应用导航" className="oy-nav-menu">

package/lib/samples/openyida-scaffold/canvas-nav/sidebar.jsx

@@ -5,15 +5,15 @@ function CanvasSidebar({ children, title, logo, actions, activeKey, defaultWidth
   const [collapsed, setCollapsed] = React.useState(defaultCollapsed);
   const [mobileOpen, setMobileOpen] = React.useState(false);
   const [width, setWidth] = React.useState(null);
-  const [viewport, setViewport] = React.useState(() => window.innerWidth);
+  const [containerWidth, setContainerWidth] = React.useState(() => window.innerWidth);
   const [resizing, setResizing] = React.useState(false);
   const [measuredWidth, setMeasuredWidth] = React.useState(216);
   const sidebar = React.useRef(null);
   const drag = React.useRef(null);
   const menuId = React.useId();
-  const mobile = viewport < 768;
+  const mobile = containerWidth < 768;
   const minWidth = 180;
-  const maxWidth = Math.min(400, Math.floor(viewport * 0.45));
+  const maxWidth = Math.min(400, Math.floor(containerWidth * 0.45));
   const clamp = value => Math.max(minWidth, Math.min(maxWidth, value));
   const expanded = mobile ? mobileOpen : !collapsed;
   const ToggleIcon = mobile ? Menu : collapsed ? PanelLeftOpen : PanelLeftClose;
@@ -25,19 +25,35 @@ function CanvasSidebar({ children, title, logo, actions, activeKey, defaultWidth
     setResizing(false);
   }
   React.useEffect(() => {
-    const resize = () => { finishResize(); setViewport(window.innerWidth); };
-    window.addEventListener('resize', resize);
     window.addEventListener('blur', finishResize);
-    return () => { window.removeEventListener('resize', resize); window.removeEventListener('blur', finishResize); finishResize(); };
+    return () => { window.removeEventListener('blur', finishResize); finishResize(); };
   }, []);
   React.useEffect(() => setMobileOpen(false), [activeKey]);
   React.useLayoutEffect(() => {
-    const observer = new window.ResizeObserver(() => setMeasuredWidth(Math.round(sidebar.current.getBoundingClientRect().width)));
-    observer.observe(sidebar.current);
-    return () => observer.disconnect();
+    const aside = sidebar.current;
+    const container = aside?.parentElement || aside;
+    if (!aside || !container) return undefined;
+    const measure = () => {
+      const nextContainerWidth = Math.round(container.getBoundingClientRect().width);
+      const nextSidebarWidth = Math.round(aside.getBoundingClientRect().width);
+      setContainerWidth(current => current === nextContainerWidth ? current : nextContainerWidth);
+      setMeasuredWidth(current => current === nextSidebarWidth ? current : nextSidebarWidth);
+    };
+    measure();
+    const observer = window.ResizeObserver ? new window.ResizeObserver(measure) : null;
+    if (observer) {
+      observer.observe(container);
+      observer.observe(aside);
+    } else {
+      window.addEventListener('resize', measure);
+    }
+    return () => {
+      if (observer) observer.disconnect();
+      else window.removeEventListener('resize', measure);
+    };
   }, []);
 
-  return <aside ref={sidebar} className="oy-nav-sidebar oy-nav-surface" data-collapsed={collapsed} data-mobile-open={mobileOpen}
+  return <aside ref={sidebar} className="oy-nav-sidebar oy-nav-surface" data-compact={mobile} data-collapsed={collapsed} data-mobile-open={mobileOpen}
     onClick={event => { if (mobile && event.target.closest('.oy-nav-menu .oy-nav-item')) setMobileOpen(false); }}
     style={{ '--oy-sidebar-width': width === null ? (typeof defaultWidth === 'number' ? `${defaultWidth}px` : defaultWidth) : `${clamp(width)}px`, '--oy-sidebar-max-width': `${maxWidth}px` }}>
     <style>{`
@@ -48,20 +64,16 @@ function CanvasSidebar({ children, title, logo, actions, activeKey, defaultWidth
       .oy-canvas-nav .oy-sidebar-resize { position: absolute; z-index: 2; top: 0; right: -4px; bottom: 0; width: 8px; cursor: col-resize; touch-action: none; }
       .oy-canvas-nav .oy-sidebar-resize:hover, .oy-canvas-nav .oy-sidebar-resize:focus-visible { background: var(--pod-nav-tab-line-selected-color, var(--color-brand1-6, #1677ff)); outline: 0; }
       .oy-canvas-nav .oy-sidebar-drag-cover { position: fixed; inset: 0; z-index: 9999; cursor: col-resize; user-select: none; }
-      @media (min-width: 768px) {
-        .oy-canvas-nav .oy-nav-sidebar[data-collapsed="true"] { width: var(--pod-nav-side-collapsed-width, 56px); }
-        .oy-canvas-nav .oy-nav-sidebar[data-collapsed="true"] .oy-nav-brand { padding: 0; }
-        .oy-canvas-nav .oy-nav-sidebar[data-collapsed="true"] .oy-nav-brand > :not(.oy-sidebar-toggle),
-        .oy-canvas-nav .oy-nav-sidebar[data-collapsed="true"] .oy-sidebar-actions,
-        .oy-canvas-nav .oy-nav-sidebar[data-collapsed="true"] .oy-nav-item[data-has-icon="true"] > span { display: none; }
-        .oy-canvas-nav .oy-nav-sidebar[data-collapsed="true"] .oy-nav-item { justify-content: center; padding: 0 4px; }
-      }
-      @media (max-width: 767px) {
-        .oy-canvas-nav .oy-nav-sidebar { width: 100%; border-right: 0; border-bottom: 1px solid var(--pod-nav-sub-divider-color, var(--color-line1-1, #ddd)); }
-        .oy-canvas-nav .oy-nav-sidebar[data-mobile-open="false"] .oy-sidebar-items,
-        .oy-canvas-nav .oy-nav-sidebar[data-mobile-open="false"] .oy-sidebar-actions { display: none; }
-        .oy-canvas-nav .oy-sidebar-resize { display: none; }
-      }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="false"][data-collapsed="true"] { width: var(--pod-nav-side-collapsed-width, 56px); }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="false"][data-collapsed="true"] .oy-nav-brand { padding: 0; }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="false"][data-collapsed="true"] .oy-nav-brand > :not(.oy-sidebar-toggle),
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="false"][data-collapsed="true"] .oy-sidebar-actions,
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="false"][data-collapsed="true"] .oy-nav-item[data-has-icon="true"] > span { display: none; }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="false"][data-collapsed="true"] .oy-nav-item { justify-content: center; padding: 0 4px; }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="true"] { width: 100%; border-right: 0; border-bottom: 1px solid var(--pod-nav-sub-divider-color, var(--color-line1-1, #ddd)); }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="true"][data-mobile-open="false"] .oy-sidebar-items,
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="true"][data-mobile-open="false"] .oy-sidebar-actions { display: none; }
+      .oy-canvas-nav .oy-nav-sidebar[data-compact="true"] .oy-sidebar-resize { display: none; }
     `}</style>
     <div className="oy-nav-brand">{logo}{title ? <span>{title}</span> : null}
       <button className="oy-nav-item oy-sidebar-toggle" type="button" title={expanded ? '收起导航' : '展开导航'}

package/lib/samples/openyida-scaffold/canvas-nav/top.jsx

@@ -19,7 +19,7 @@ function CanvasNav({ items = [], activeKey, onSelect, title, logo, actions, chil
       .oy-nav-top .oy-nav-menu .oy-nav-item { min-height: var(--pod-nav-top-tab-height, 40px); padding: var(--pod-nav-top-tab-item-padding, 0 12px); max-width: var(--pod-nav-top-tab-item-max-width, 240px); }
       .oy-nav-top .oy-nav-menu .oy-nav-item > span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
       .oy-nav-top .oy-nav-toggle { display: none; margin-left: auto; }
-      @media (max-width: 767px) {
+      @container (max-width: 767px) {
         .oy-nav-top .oy-nav-header { gap: var(--pod-nav-logo-gap, 8px); }
         .oy-nav-top .oy-nav-toggle { display: flex; }
         .oy-nav-top .oy-nav-menu { order: 1; flex-basis: 100%; flex-direction: column; }

package/lib/samples/openyida-scaffold/canvas-responsive-layout.jsx

@@ -0,0 +1,104 @@
+import React from 'react';
+
+const DEFAULT_BREAKPOINTS = Object.freeze({ compact: 600, stacked: 768, wide: 1024 });
+
+function getLayout(width, breakpoints) {
+  if (width < breakpoints.compact) return 'compact';
+  if (width < breakpoints.wide) return 'regular';
+  return 'wide';
+}
+
+/**
+ * Observe the actual content container instead of assuming it equals the browser viewport.
+ * Updates are coalesced with requestAnimationFrame and only committed when width/bucket changes.
+ */
+function useContainerLayout(breakpoints = DEFAULT_BREAKPOINTS) {
+  const rootRef = React.useRef(null);
+  const frameRef = React.useRef(0);
+  const [measurement, setMeasurement] = React.useState({ width: 0, layout: 'regular' });
+
+  React.useLayoutEffect(() => {
+    const root = rootRef.current;
+    if (!root) return undefined;
+    let active = true;
+    const measure = () => {
+      if (!active) return;
+      if (frameRef.current) window.cancelAnimationFrame(frameRef.current);
+      frameRef.current = window.requestAnimationFrame(() => {
+        frameRef.current = 0;
+        if (!active) return;
+        const width = Math.round(root.getBoundingClientRect().width);
+        const layout = getLayout(width, breakpoints);
+        setMeasurement(current => current.width === width && current.layout === layout
+          ? current
+          : { width, layout });
+      });
+    };
+    measure();
+    const observer = window.ResizeObserver ? new window.ResizeObserver(measure) : null;
+    if (observer) observer.observe(root);
+    else window.addEventListener('resize', measure);
+    return () => {
+      active = false;
+      if (observer) observer.disconnect();
+      else window.removeEventListener('resize', measure);
+      if (frameRef.current) window.cancelAnimationFrame(frameRef.current);
+    };
+  }, [breakpoints.compact, breakpoints.wide]);
+
+  return { rootRef, ...measurement };
+}
+
+/**
+ * A reusable content shell for filters, primary/secondary panels, charts and wide tables.
+ * Business state stays above this shell, so crossing a breakpoint never remounts it.
+ */
+function ResponsiveLayout({ filters, actions, primary, secondary, chart, table, breakpoints = DEFAULT_BREAKPOINTS }) {
+  const { rootRef, width, layout } = useContainerLayout(breakpoints);
+  return (
+    <section ref={rootRef} className="oy-responsive-root" data-layout={layout} data-container-width={width || undefined}>
+      <style>{`
+        .oy-responsive-root { container: oy-content / inline-size; min-width: 0; display: grid; gap: var(--oy-section-gap, 16px); color: var(--color-text1-4, #1f2329); }
+        .oy-responsive-root, .oy-responsive-root * { box-sizing: border-box; }
+        .oy-responsive-filters { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 220px), 1fr)); gap: 12px; align-items: end; min-width: 0; }
+        .oy-responsive-actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+        .oy-responsive-panels { display: grid; grid-template-columns: minmax(0, 2fr) minmax(240px, 1fr); gap: 16px; align-items: stretch; min-width: 0; }
+        .oy-responsive-panel { min-width: 0; overflow-wrap: anywhere; }
+        .oy-responsive-chart { min-width: 0; min-height: 240px; }
+        .oy-responsive-table { min-width: 0; max-width: 100%; overflow-x: auto; overscroll-behavior-inline: contain; }
+        .oy-responsive-table > table { width: 100%; min-width: 720px; border-collapse: collapse; }
+        .oy-responsive-drawer-body { min-width: 0; container-type: inline-size; }
+        @container oy-content (max-width: ${breakpoints.stacked - 1}px) {
+          .oy-responsive-panels { grid-template-columns: minmax(0, 1fr); }
+        }
+        @container oy-content (max-width: ${breakpoints.compact - 1}px) {
+          .oy-responsive-filters { grid-template-columns: minmax(0, 1fr); }
+          .oy-responsive-actions > * { flex: 1 1 auto; min-width: 0; }
+          .oy-responsive-chart { min-height: 200px; }
+        }
+      `}</style>
+      <div className="oy-responsive-filters">{filters}<div className="oy-responsive-actions">{actions}</div></div>
+      <div className="oy-responsive-panels">
+        <div className="oy-responsive-panel">{primary}</div>
+        <aside className="oy-responsive-panel">{secondary}</aside>
+      </div>
+      <div className="oy-responsive-chart" data-chart-width={width || undefined}>{chart}</div>
+      <div className="oy-responsive-table" tabIndex={0} aria-label="可横向滚动的数据表格">{table}</div>
+    </section>
+  );
+}
+
+/** Example keeps filter state while the observed container crosses every breakpoint. */
+export default function ResponsiveLayoutExample() {
+  const [keyword, setKeyword] = React.useState('');
+  return <ResponsiveLayout
+    filters={<label>关键词<input value={keyword} onChange={event => setKeyword(event.target.value)} /></label>}
+    actions={<><button type="button">查询</button><button type="button">清空</button></>}
+    primary={<div>主内容面板</div>}
+    secondary={<div>辅助信息与超长编号：OPENYIDA-RESPONSIVE-CONTAINER-CONTENT-IDENTIFIER</div>}
+    chart={<div role="img" aria-label="图表区域">图表应按 data-chart-width 调用自身 resize</div>}
+    table={<table><thead><tr><th>名称</th><th>状态</th><th>负责人</th><th>操作</th></tr></thead><tbody><tr><td>示例记录</td><td>进行中</td><td>当前用户</td><td><button type="button">查看</button></td></tr></tbody></table>}
+  />;
+}
+
+export { DEFAULT_BREAKPOINTS, ResponsiveLayout, getLayout, useContainerLayout };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openyida",
-  "version": "2026.10.21",
+  "version": "2026.10.22",
   "description": "OpenYida CLI - 宜搭低代码 AI 开发工具（安装即用，零配置）",
   "bin": {
     "openyida": "bin/yida.js",

package/scripts/postinstall.js

@@ -307,6 +307,7 @@ openyida copy
 
 ## 子技能目录
 
+已有流程的当前任务查询、流程审批转交或管理员转交，直接加载 \`yida-data-management\`，使用 \`data query process-tasks\` 和 \`data transfer task\`，并回读实际处理人。修改流程中的转交操作权限才使用 \`yida-process-rule\`。
 原生酷卡片仅在用户明确指定宜搭原生酷卡片（交互/置顶卡片）或继续已明确上下文时加载 \`yida-cool-card\`。它用 cardPageCode/cardTemplateId；CARD 资源和 dataCardDesigner 属于 \`yida-data-card\`，Canvas 展示卡片归页面。酷卡片 CLI 负责创建、读取与模板查询，返回官方入口由用户配置保存，再由 CLI 回读；不代替编辑器保存、发布或发送，不修改权益或官方卡片开关。
 原生数据卡片仅在用户显式指定宜搭原生数据卡片，或继续已明确的原生卡片操作时加载 \`yida-data-card\`。泛称卡片、指标卡、看板、投放或数据播报不触发；完整应用搭建也不自动添加该资源。自定义页面内的卡片随页面发布；页面虽有 CARD 引用，只改外层仍属页面任务，明确修改源卡片才进入原生卡片技能。
 

package/yida-skills/SKILL.md

@@ -16,7 +16,7 @@ Fast / Plan 选定的主题和主色属于整个应用：导航、原生页、
 
 ## 本地使用问题与贡献反馈
 
-用户遇到反复报错、不会提 Issue/PR、没有 GitHub 账号或没有 OpenYida 源码，先加载 `yida-feedback`。
+用户反馈 OpenYida 使用问题或体验建议、想贡献改进、不会提 Issue/PR，先加载 `yida-feedback`；没有 GitHub 账号或源码也可先整理材料。
 它负责基于当前证据分析根因、生成脱敏本地材料，并按用户授权提交 Issue 或个人 Fork PR。无账号先引导注册，实在不行提示“反馈到AI开发者群”。
 自动发现重复失败只建议并整理本地草稿，不自动公开提交。网页关联本地 Agent 异常先按下节诊断，需要反馈时再进入此技能。普通宜搭产品 VOC 清单仍用 `yida-voc`。
 
@@ -159,7 +159,7 @@ Fast / Plan 选定的主题和主色属于整个应用：导航、原生页、
 | --- | --- |
 | 从零搭一个完整应用/系统 | `yida-app`；先分析需求并完成首次搭建确认，再规划与搭建 |
 | 已有 app 但没有任何页面，需要补成完整系统 | `yida-app`；属于首次搭建，同样先询问搭建方式，复用已有 `appType` 补齐资源 |
-| OpenYida 反复报错、不会提 Issue/PR、没有账号或源码 | `yida-feedback`；先脱敏本地报告，个人 Fork 仅贡献公开 OpenYida 修复 |
+| OpenYida 使用问题、体验建议、希望贡献改进或不会提 Issue/PR | `yida-feedback`；先整理脱敏材料，成功提交 Issue 后可选邀请 PR，贡献代码使用个人 Fork |
 | 读取钉钉在线文档正文 | `yida-document-markdown`，使用登录态接口获取 Markdown |
 | 按 taskUuid 读取钉钉听记 | `yida-tingji`，将听记任务 ID 原样传入命令 |
 | 将钉钉开放平台官方 API 接入宜搭或 Canvas | `yida-dingtalk-openapi`；密钥不进聊天，账号由用户在宜搭或本机 TTY 配置 |
@@ -180,6 +180,7 @@ Fast / Plan 选定的主题和主色属于整个应用：导航、原生页、
 | 流程设计器字段列表空白 | `yida-process-rule`，先用 `process fields` 检查字段来源 |
 | 查字段 ID / 保存 Schema 证据 | `yida-get-schema`；凡涉及 fieldId 的数据、流程、公式、页面代码先取证 |
 | 改表单数据记录 | `yida-data-management`，不是 `yida-create-form-page` |
+| 查询流程当前任务、管理员转交已有流程任务 | `yida-data-management`；先查询 process-tasks，再 transfer task 并回读实际处理人 |
 | 查询指定应用/流程表单中当前审批人为某人的实例或条数 | `yida-data-management`；`data query process --current-approver <userId> [--count]`，仅统计当前登录人经服务端授权可见的实例 |
 | 配置或修改公式、字段计算、提交校验、节点筛选、报表计算 | 共用 `yida-formula`，按实际保存内容读取说明；查看字段公式、查参数和检查用 `yida-formula-evaluate` |
 | 提交后跨表写入/更新/删除 | 默认 `yida-integration`；用户明确要业务关联规则/高级函数时用 `yida-business-rule` |

package/yida-skills/skills/yida-canvas-custom-page/SKILL.md

@@ -11,7 +11,11 @@ description: 宜搭自定义页面开发规范，使用 `YidaCodeCanvas` 组件
 
 待办中心或审批任务区块只有在用户明确要求自定义实现，或经 ask_human 明确同意后才交接 `yida-task-center`；已有 Canvas、普通工作台需求或 Fast 模式不构成选择。未选择时保留原生能力，不直接手写任务中心。
 
-布局实现读取 [共享响应式规则](../yida-design/references/responsive-layout.md)：按实际容器宽度重排筛选栏和主辅面板，统一同组控件尺寸，宽屏按需等高、窄屏自然增长，宽表格局部滚动。断点变化保留原组件状态与业务行为，发布前按该文档验收。
+布局实现分三步，详细规则见 [共享响应式规则](../yida-design/references/responsive-layout.md)：
+
+1. **读取设计**：从 `design.md` 读取当前页的首屏焦点、布局、主操作、响应式和验收要求。
+2. **实现布局**：优先用 CSS 按内容容器宽度重排。需要参考时执行 `openyida sample openyida-page-template canvas-responsive-layout`，按需复用与当前业务对应的布局片段；图表等组件需要读取实际宽度时，再复用测量 Hook。视口媒体查询用于浏览器视口或输入方式判断。
+3. **验证状态**：切换宽度前后保留原组件状态与业务行为，发布前按共享规则检查实际页面。
 
 已有页面的美化或 UI 优化，先进入 [ui-improve](../yida-design/sub_skill/ui-improve/SKILL.md)。只有当前视觉方案已通过 `ask_human` 确认且原状态备份可恢复，才修改源码；交接需包含获批 revision、范围、备份和功能契约。本轮仅按视觉差异修改，保留现有业务表达式、事件、数据绑定、URL、状态管理和打开方式，不套用下文的新页面默认规则改变业务。
 

package/yida-skills/skills/yida-custom-page/SKILL.md

@@ -5,7 +5,11 @@ description: JSX 自定义页面开发规范（React 16 平台 Jsx 组件、expo
 
 # JSX 自定义页面开发
 
-布局实现读取 [共享响应式规则](../yida-design/references/responsive-layout.md)：按实际容器宽度重排筛选栏和主辅面板，统一同组控件尺寸，宽屏按需等高、窄屏自然增长，宽表格局部滚动。使用原 JSX 运行时支持的样式能力，断点变化保留原组件状态与业务行为，发布前按该文档验收。
+布局实现分三步，详细规则见 [共享响应式规则](../yida-design/references/responsive-layout.md)：
+
+1. **读取设计**：从 `design.md` 读取当前页的首屏焦点、布局、主操作、响应式和验收要求。
+2. **实现布局**：使用原 JSX 运行时支持的样式能力，按需复用与当前业务对应的布局片段，实现宽窄排列、控件对齐和局部滚动。
+3. **验证状态**：切换宽度前后保留原组件状态与业务行为，发布前按共享规则检查实际页面。
 
 已有页面美化先进入 [ui-improve](../yida-design/sub_skill/ui-improve/SKILL.md)：视觉方案经 `ask_human` 确认、备份可恢复后才修改。沿用获批范围和功能契约，保留原 JSX 运行时、业务表达式、数据源、事件及入口行为；下文的新开发默认规则不用于顺手重构已有业务。不满意时由该流程恢复本轮前状态。
 
@@ -57,7 +61,7 @@ UI 组件及 JSX 展示结构允许替换，业务函数及业务状态实现不
 4. **默认 Tailwind 风格层 + native 控件 reset**：面向用户的自定义页面默认使用 Tailwind utility className 组织视觉层，并默认导入 Tailwind preflight；同时必须保留 `openyida-native-control-reset` 或等效页面级样式，覆盖 input/textarea/select/自定义下拉的 focus、appearance、font-weight 和 shadow，避免浏览器黑色粗边。reset 使用 `.oyd-page` 通用作用域时可以复用全局 id，但不能因为同名 style 已存在就跳过更新；如果页面使用 `.oyd-grade-page`、`.oyd-data-page` 等自定义作用域，style id 必须页面专属，避免多 native 页面切换时下拉选项和 SVG 勾选样式丢失。运行时脚本只允许使用已验证的 `g.alicdn.com` 或企业自托管地址，未配置有效地址时走内联兜底样式
 5. **DateField 时间戳格式**：日期字段值必须是时间戳（毫秒），不能是字符串
 6. **forceUpdate 后延迟操作 DOM**：`forceUpdate()` 后 DOM 不会立即更新，ECharts/Canvas/第三方组件初始化必须放入 `setTimeout` 或 `requestAnimationFrame`
-7. **多端适配**：使用 `this.utils.isMobile()` 判断设备类型，适配 PC 和移动端
+7. **多端适配**：按实际内容容器宽度决定布局；`this.utils.isMobile()` 用于选择平台移动入口等设备相关行为。触控与键盘操作按当前设计及共享响应式规则实现。
 8. **输入法组合输入处理**：使用 `_isComposing` 标记配合 `compositionstart`/`compositionend` 事件，避免输入过程中触发提交
 9. **表单打开入口统一容器**：数据列表用 `workbench/{formUuid}?iframe=true`，禁止用 `formDetail` 冒充列表；新增/提交/查看详情入口统一封装为 `FormOpenContainer`。PC 端默认用半屏 `50vw` 抽屉 iframe 承载页面级隐藏导航的 `submission/{formUuid}?isRenderNav=false` 或 `formDetail/{formUuid}?formInstId=...&navConfig.layout=1180&isRenderNav=false`，提交页和详情页使用同一宽度规则；详情实例 ID 必须优先取 `row.formInstId`，缺失时禁用或提示，不打开空 `formInstId`；移动端才整页或新页打开原生表单页；不要在按钮里直接 `window.open`
 10. **Tabs 显隐控制**：下拉值变更后自动回退到第一个可见 Tab，内容区用 `display: none` 保留 DOM

package/yida-skills/skills/yida-data-management/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: yida-data-management
-description: 查询、新增、更新宜搭表单和流程数据，按当前审批人查询流程实例或统计条数，精确删除普通表单单条记录。支持日期为空、日期区间端点、多选数量、子表条件及服务端分页；表单使用 /v1/form/，流程使用 /v1/process/。
+description: 查询、新增、更新宜搭表单和流程数据，按当前审批人查询流程实例或统计条数，精确删除普通表单单条记录，查询指定流程当前任务并执行管理员转交。支持日期为空、日期区间端点、多选数量、子表条件及服务端分页；表单使用 /v1/form/，流程使用 /v1/process/。
 ---
 
 # 数据管理
@@ -50,7 +50,7 @@ description: 查询、新增、更新宜搭表单和流程数据，按当前审
 ## 严格要求 (MUST DO)
 
 - 操作前先用 query 命令确认目标数据存在
-- 所有 create/update/delete/execute 写操作必须携带只读预检确认的资源名称和类型；CLI 校验不一致时停止，不得换目标重试
+- 所有 create/update/delete/execute/transfer 写操作必须携带只读预检确认的资源名称和类型；CLI 校验不一致时停止，不得换目标重试
 - 新增记录、生成测试数据、批量导入或发起流程必须遵守上方“创建/录入数据强制闭环”
 - 批量操作单次不超过 30 条记录；多条实例必须逐条/分批执行 `openyida data create ...`
 - 删除普通表单记录前，必须先执行 `openyida data get form <appType> --inst-id <formInstId> --form-uuid <formUuid> --json`，核对返回实例 ID 与目标表单，并向用户展示记录数量、标题/关键字段和实例 ID。宿主支持并会在执行删除命令前触发 runtime permission/approval 时，直接发起一次带 `--confirm` 的受保护删除命令，由该唯一权限卡完成用户确认；无需且不得预先调用 `ask_human` 或其他业务确认工具。宿主不支持 runtime permission/approval 时，必须先通过 `ask_human` 或等价交互工具获得用户明确确认；只有用户确认后才能执行删除，用户拒绝或未确认时不得执行
@@ -98,6 +98,7 @@ description: 查询、新增、更新宜搭表单和流程数据，按当前审
 - "查询数据"、"新增记录"、"更新数据"
 - "查看表单实例"、"发起流程"
 - "录入数据"、"批量导入"、"查询待办任务"
+- "查询流程当前任务"、"管理员转交"、"把这条流程转交给某人"
 - "按当前审批人统计"、"某人的待审批流程条数"、"查询指定审批人的流程实例"
 
 > ⚠️ 表单接口（`/v1/form/`）和流程接口（`/v1/process/`）不能混用。
@@ -216,6 +217,23 @@ openyida data query tasks <appType> --type todo|created|done|cc --normalized [--
 
 只读数量、流程详情和审批历史可独立使用 `task-center count / inspect`，无需选择自定义页面；返回含义与按需装配见[流程任务能力](../yida-canvas-data-binding/references/workflow-capabilities.md)。
 
+### 流程当前任务与管理员转交
+
+```bash
+openyida data query process-tasks <appType> --process-inst-id <processInstanceId> --json
+openyida data transfer task <appType> --process-inst-id <processInstanceId> --form-uuid <formUuid> --to-user-id <userId> --expect-form-name <真实表单名称> --expect-form-type process [--remark '用户说明的理由'] [--task-id <taskId>] --json
+```
+
+- 这是管理员对已有流程任务的转交；审批同意/拒绝仍使用 `execute task`，配置转交操作权限使用 `yida-process-rule`，流程代理使用 `yida-agent-center`。
+- 先查询流程确认实例及表单，再查询 `process-tasks` 展示任务、节点和实际处理人；明确接收人的真实 userId，名称有歧义时不能猜选。不要用“我的待办”代替指定流程的管理员任务查询。
+- 用户未说明转交理由时，省略 `--remark`，CLI 固定写“转交”；用户说明了理由时，使用其原话传入 `--remark`。不要自行添加“按用户要求”等理由，也不要为缺少理由追问用户。
+- `taskId` 来自任务接口 `content[].id`，CLI 同时输出字符串 `taskId`；禁止使用 `currentActivityInstances[].id`、`taskSequenceId`、`taskGroupId` 或从 URL 猜测任务 ID。
+- CLI 会在写前重新查询任务：只有一个运行任务时可省略 `--task-id`，多个任务必须明确指定；任务已结束或不属于目标实例时停止。
+- 完成以 `transferred=true && readbackVerified=true` 为准；`ALREADY_ASSIGNED` 表示任务已由接收人处理，本次没有转交写入。接口 `success=true/content=null` 仅代表受理，CLI 还必须回读确认实际处理人。
+- 收到 `RESULT_UNKNOWN` / `UNVERIFIED`、提交超时或鉴权异常时，仅按错误 `details.nextStep` 只读回查，禁止自动重放转交。此规则优先于下方通用网络重试策略。
+
+接口、回读规则与错误恢复见 [流程任务查询与管理员转交](references/process-task-transfer.md)。
+
 ## 接口总览
 
 ### 表单实例
@@ -244,6 +262,8 @@ openyida data query tasks <appType> --type todo|created|done|cc --normalized [--
 | `updateInstance` | POST | 更新 |
 | `getOperationRecords` | GET | 审批记录 |
 | `executeTask` | POST | 执行任务 |
+| `getInstTaskDatas` | GET | 管理员查询指定流程任务，使用 query/formProcInstData 路径 |
+| `redirectTask` | POST | 管理员转交任务，使用 query/instance 路径，单次提交并回读 |
 
 ### 任务中心
 
@@ -396,11 +416,12 @@ openyida data create form APP_xxx FORM-商机表 --expect-form-name 商机表 --
 | 错误类型 | 默认处理策略 |
 |---------|-------------|
 | 命令执行失败 | 停止执行，向用户展示错误信息，询问是否重试或调整参数 |
+| 管理员转交失败或结果未验证 | 禁止自动重放转交；按 details.nextStep 只读核查并报告 mutationAccepted/readbackVerified，后续写入须重新核对当前任务和用户意图 |
 | 参数缺失（appType/formUuid/fieldId 等） | 主动询问用户补充，或引导用户使用 `yida-get-schema` 获取 |
 | 权限不足 / 登录态失效 | 停止执行，提示用户执行 `openyida login` 重新登录 |
 | 字段 ID 无效 | 停止执行，引导用户执行 `openyida get-schema` 获取真实字段 ID |
 | 删除操作前 | 必须先展示操作摘要（数量 + 关键字段）；宿主支持 runtime permission/approval 时直接发起一次受保护命令，不得预先调用 `ask_human`；宿主不支持时，必须先通过 `ask_human` 或等价交互工具获得用户明确确认 |
 | QPS 超限 | 降低请求频率，单次批量操作不超过 30 条，间隔 1 秒重试 |
 | 表单/流程接口混用 | 停止执行，提示用户检查接口类型（表单用 `/v1/form/`，流程用 `/v1/process/`） |
-| 网络超时 | 重试 1 次，仍失败则停止并提示用户检查网络 |
+| 网络超时 | 查询可重试 1 次；管理员转交禁止自动重试提交，仅按 nextStep 只读回查，仍无法验证则报告结果未知 |
 | 未知错误 | 停止执行，完整展示错误信息，建议用户反馈问题 |

package/yida-skills/skills/yida-data-management/references/process-task-transfer.md

@@ -0,0 +1,53 @@
+# 流程任务查询与管理员转交
+
+现有 `data query form/process` 列表接口保持不变。以下接口属于管理员任务操作，不使用浏览器 Cookie 或抓包中的 CSRF token；复用 CLI token session、环境 baseUrl 和受管任务授权。`byManager=true` 不授予管理员权限，平台仍校验当前身份。
+
+## 查询指定流程任务
+
+`openyida data query process-tasks <appType> --process-inst-id <processInstanceId> --json`
+
+- GET `/dingtalk/web/<appType>/query/formProcInstData/getInstTaskDatas.json`
+- `_api=DataManage.getInstTasks`，`procInstId=<processInstanceId>`。
+- 成功响应 `content` 为任务数组，空数组表示未查到任务；查询失败不能当成无任务。
+- 每条任务 `processInstanceId` 必须等于目标实例，`id` 必须是正整数，重复 ID 或不合法结构停止操作。
+- CLI 保留原始任务字段，并新增字符串 `taskId`，由 `id` 转换；不会解析任务 URL。
+
+| 返回字段 | 含义 |
+| --- | --- |
+| `id` / `taskId` | 转交目标任务 ID |
+| `status` | 仅 `RUNNING` 可转交 |
+| `activityCode` / `groupName` | 所属节点 / 节点名称 |
+| `actualActionerId` / `actualActionerDisplayName` | 当前实际处理人 |
+| `originalActionerId` | 原始处理人，不用于验证转交后的接收人 |
+| `taskGroupId` | 任务组标识，不是任务 ID |
+
+## 管理员转交
+
+```bash
+openyida data transfer task APP_xxx --process-inst-id <processInstanceId> --form-uuid FORM-xxx --to-user-id <真实接收人userId> --expect-form-name <真实表单名称> --expect-form-type process --task-id <taskId> [--remark '用户说明的理由'] --json
+```
+
+- POST `/dingtalk/web/<appType>/query/instance/redirectTask.json`。
+- `_api=DataManage.redirectTask`；表单编码参数为 `taskId`、`procInstId`、`nowActionerId`（接收人）、`remark`、`byManager=true`。
+- 用户未说明理由时，省略可选参数 `--remark`，CLI 默认备注为“转交”；用户说明理由时，原样传入 `--remark`，不添加前缀或自行编写理由。显式空备注或只有 `--remark` 没有值属于参数错误。
+- 写前校验资源名称、类型及实例归属，再重查任务。只有一个运行任务时可省略 taskId；多个运行任务必须明确选择，禁止默认选择第一条。
+- 不修改业务字段，不需要为转交准备 data-json/data-file 或字段映射；接收人必须来自用户明确指定或真实通讯录解析，不得编造。
+- 接收人已是该任务的实际处理人时，返回 `ALREADY_ASSIGNED`、`mutationPerformed=false`，不提交转交。
+- 单次提交，不因登录刷新、网络超时或空响应自动重放。`success=true/content=null` 是正常受理响应。
+
+## 回读与结果
+
+受理后立即重新查该流程任务。以下证据才算转交已验证：
+
+1. 原 taskId 仍为 RUNNING，且 `actualActionerId` 等于接收人；或
+2. 原任务不再运行，且同 `activityCode/taskGroupId` 出现唯一新增 RUNNING 任务，实际处理人为接收人。已有并行任务、仅 originalActionerId 匹配、旧任务消失但无新任务，都不足以证明成功。
+
+| 结果 | 行为 |
+| --- | --- |
+| `TRANSFERRED` | `transferred=true`、`mutationAccepted=true`、`readbackVerified=true`；输出原 taskId 与 currentTaskId |
+| `ALREADY_ASSIGNED` | `transferred=false`、`readbackVerified=true`，无需转交写入 |
+| `REJECTED` | 平台明确拒绝，报告错误，核对权限与任务状态 |
+| `RESULT_UNKNOWN` | 提交超时、鉴权异常、非 JSON 等；仅按 details.nextStep 只读回查，禁止自动重放 |
+| `UNVERIFIED` | 已受理但回读失败或不能确认接收人；仅按 details.nextStep 只读回查，禁止自动重放 |
+
+不得把命令退出成功、旧任务消失、列表 actionerId 为空或仅接口受理当作转交验收通过。不能证明结果时如实报告，不改用一次性脚本或浏览器请求绕过 CLI。