openyida 2026.9.8-1 → 2026.9.8

package/README.md

@@ -174,8 +174,6 @@ openyida update-app APP_XXX --theme-file .cache/openyida/crm/app-theme.css --nav
 openyida corp-efficiency
 openyida create-form create APP_XXX "Customer" .cache/openyida/forms/customer-fields.json
 openyida create-form update APP_XXX FORM_XXX .cache/openyida/forms/customer-changes.json
-openyida create-form update APP_XXX FORM_XXX --data-file .cache/openyida/forms/customer-changes.json
-openyida create-form resume APP_XXX FORM_XXX .cache/openyida/forms/customer-fields.json --json
 openyida sample openyida-page-template form-fields --output .cache/openyida/forms/customer-fields.json
 openyida sample openyida-page-template canvas-form-drawer --output project/pages/src/customer-entry.canvas.jsx --var APP_TYPE=APP_XXX --var FORM_UUID=FORM_XXX
 openyida get-schema APP_XXX FORM_XXX
@@ -415,8 +413,7 @@ Run `openyida --help` or `openyida <command> --help` for detailed usage.
 | `openyida create-form create <appType> "<formTitle>" <fieldsJsonFile> [--icon auto\|<iconName>] [--locale zh_CN\|en_US\|ja_JP] [--open\|--no-open]` | Create a form page |
 | `openyida create-form icons [--json]` | List available form navigation icons |
 | `openyida create-form validate-fields <fieldsJsonOrFile> [--json]` | Validate form field JSON locally |
-| `openyida create-form update <appType> <formUuid> (<changesJsonOrFile> \| --data-file <changesJsonOrFile>) [--locale zh_CN\|en_US\|ja_JP] [--open\|--no-open]` | Update a form page |
-| `openyida create-form resume <appType> <formUuid> <fieldsJsonOrFile> [--json]` | Update a form page |
+| `openyida create-form update <appType> ... [--locale zh_CN\|en_US\|ja_JP] [--open\|--no-open]` | Update a form page |
 | `openyida create-form patch <appType> <formUuid> <patchJsonOrFile> [--open\|--no-open]` | Update a form page |
 | `openyida create-form rule <appType> <formUuid> <rulesJsonOrFile> [--open\|--no-open]` | Update a form page |
 | `openyida create-form validation <appType> <formUuid> <validationsJsonOrFile> [--open\|--no-open]` | Update a form page |

package/lib/app/create-form/args.js

@@ -89,7 +89,6 @@ function createParseArgs(dependencies) {
       contentLocale: null,
       browserOpenMode: openOption.mode,
     };
-    let dataFileInput;
 
     const args = [...rawArgs];
 
@@ -112,14 +111,6 @@ function createParseArgs(dependencies) {
         i--;
       } else if (args[i] === '--icon') {
         throwCreateFormError('--icon requires a value', 'CREATE_FORM_INVALID_ARGUMENTS');
-      } else if (args[i] === '--data-file') {
-        const next = args[i + 1];
-        if (dataFileInput !== undefined || !next || next.startsWith('--')) {
-          throwCreateFormError('--data-file requires exactly one value', 'CREATE_FORM_INVALID_ARGUMENTS');
-        }
-        dataFileInput = next;
-        args.splice(i, 2);
-        i--;
       } else if ((args[i] === '--locale' || args[i] === '--content-locale' || args[i] === '--lang') && i + 1 < args.length) {
         options.contentLocale = args[i + 1];
         if (!normalizeYidaLocale(options.contentLocale)) {
@@ -154,10 +145,6 @@ function createParseArgs(dependencies) {
 
     const mode = args[0];
 
-    if (dataFileInput !== undefined && mode !== 'update') {
-      throwCreateFormError('--data-file is only supported by create-form update', 'CREATE_FORM_INVALID_ARGUMENTS');
-    }
-
     if (mode === 'icons' || mode === 'list-icons') {
       return {
         mode: 'icons',
@@ -195,12 +182,7 @@ function createParseArgs(dependencies) {
     }
 
     if (mode === 'update') {
-      const positionalInput = args[3];
-      if (args.length > 4 || (positionalInput && dataFileInput !== undefined)) {
-        throwCreateFormError('Use either <changesJsonOrFile> or --data-file, not both', 'CREATE_FORM_INVALID_ARGUMENTS');
-      }
-      const changesJsonOrFile = dataFileInput !== undefined ? dataFileInput : positionalInput;
-      if (args.length < 3 || !changesJsonOrFile) {
+      if (args.length < 4) {
         usage(t('create_form.usage_update'), t('create_form.example_update'));
         throwCreateFormError(t('create_form.usage_update'), 'CREATE_FORM_INVALID_ARGUMENTS');
       }
@@ -208,23 +190,7 @@ function createParseArgs(dependencies) {
         mode: 'update',
         appType: args[1],
         formUuid: args[2],
-        changesJsonOrFile,
-        ...options
-      };
-    }
-
-    if (mode === 'resume') {
-      if (args.length !== 4) {
-        throwCreateFormError(
-          'openyida create-form resume <appType> <formUuid> <fieldsJsonOrFile> --json',
-          'CREATE_FORM_INVALID_ARGUMENTS'
-        );
-      }
-      return {
-        mode: 'resume',
-        appType: args[1],
-        formUuid: args[2],
-        fieldsJsonOrFile: args[3],
+        changesJsonOrFile: args[3],
         ...options
       };
     }

package/lib/app/create-form/batch.js

@@ -101,10 +101,7 @@ function execute(args) {
 }
 
 async function schedule(forms, concurrency, results, worker, save) {
-  const pending = new Set(forms.filter(form => {
-    const result = results[form.key];
-    return !result || result.status === 'blocked' || (result.status === 'failed' && result.formUuid);
-  }).map(form => form.key));
+  const pending = new Set(forms.filter(form => !results[form.key] || results[form.key].status === 'blocked').map(form => form.key));
   const active = new Map();
   try {
     while (pending.size || active.size) {
@@ -117,7 +114,7 @@ async function schedule(forms, concurrency, results, worker, save) {
         }
         if (active.size >= concurrency || deps.some(status => status !== 'success')) { continue; }
         pending.delete(form.key);
-        results[form.key] = { ...results[form.key], status: 'running' };
+        results[form.key] = { status: 'running' };
         save(); // Record intent before the request; an interrupted create is never retried automatically.
         const task = Promise.resolve().then(() => worker(form)).then(output => {
           results[form.key] = { ...output, status: 'success' };
@@ -181,30 +178,16 @@ async function run(args, dependencies = {}) {
       return matches[0].fieldId;
     };
     await schedule(forms, options.concurrency, state.results, async form => {
-      let formUuid = form.formUuid || state.results[form.key]?.formUuid;
-      let shouldResume = Boolean(!form.formUuid && formUuid);
-      const resolvedFields = mapReferences(form.fields, resolve);
+      let formUuid = form.formUuid;
       if (!formUuid) {
-        const argv = ['create-form', 'create', options.appType, form.title, JSON.stringify(resolvedFields), '--no-open'];
+        const argv = ['create-form', 'create', options.appType, form.title, JSON.stringify(mapReferences(form.fields, resolve)), '--no-open'];
         for (const key of ['icon', 'locale']) { if (form[key]) { argv.push(`--${key}`, form[key]); } }
-        try {
-          const created = await call(argv);
-          if (typeof created.formUuid !== 'string' || !created.formUuid.startsWith('FORM')) { invalid(`create result: ${form.key}`); }
-          formUuid = created.formUuid;
-        } catch (error) {
-          const createdFormUuid = error.output?.formUuid || error.output?.details?.formUuid;
-          if (typeof createdFormUuid !== 'string' || !createdFormUuid.startsWith('FORM')) {
-            throw error;
-          }
-          formUuid = createdFormUuid;
-          shouldResume = true;
-        }
+        const created = await call(argv);
+        if (typeof created.formUuid !== 'string' || !created.formUuid.startsWith('FORM')) { invalid(`create result: ${form.key}`); }
+        formUuid = created.formUuid;
       }
       state.results[form.key].formUuid = formUuid;
       save(state);
-      if (shouldResume) {
-        await call(['create-form', 'resume', options.appType, formUuid, JSON.stringify(resolvedFields), '--json']);
-      }
       const schema = await call(['get-schema', options.appType, formUuid, '--field-map-json']);
       if (schema.formUuid !== formUuid || !Array.isArray(schema.fields)) { invalid(`schema: ${form.key}`); }
       return { formUuid, fields: schema.fields };

package/lib/app/create-form/commands.js

@@ -6,8 +6,6 @@ function dispatchCreateFormCommand(parsedArgs, authContext, handlers) {
   switch (parsedArgs.mode) {
     case 'update':
       return handlers.update(...args);
-    case 'resume':
-      return handlers.resume(...args);
     case 'patch':
       return handlers.patch(...args);
     case 'rule':

package/lib/app/create-form.js

@@ -5911,297 +5911,6 @@ async function mainValidation(parsedArgs, authRef) {
 
 // ── update 模式主流程 ─────────────────────────────────
 
-function collectResumeFieldEvidence(fields, output) {
-  const evidence = output || [];
-  (fields || []).forEach(function (field) {
-    if (!field || typeof field !== 'object') {
-      return;
-    }
-    const labelText = extractLabelText(field);
-    if (labelText && !isFormPresentationComponent(field.componentName)) {
-      evidence.push({
-        label: labelText,
-        componentName: field.componentName,
-        fieldId: field.props && field.props.fieldId ? field.props.fieldId : null,
-      });
-    }
-    if (Array.isArray(field.children)) {
-      collectResumeFieldEvidence(field.children.flat(), evidence);
-    }
-  });
-  return evidence;
-}
-
-function desiredResumeFieldIdentity(field) {
-  const labelValue = field && field.label;
-  const label = typeof labelValue === 'string'
-    ? labelValue
-    : labelValue && (labelValue.zh_CN || labelValue.ja_JP || labelValue.en_US || labelValue.pureEn_US);
-  return {
-    label: String(label || '').trim(),
-    componentName: normalizeFormDefinitionType(field),
-  };
-}
-
-function collectResumeDesiredFields(fields, options) {
-  const output = [];
-  const verifyNestedFields = Boolean(options && options.verifyNestedFields);
-
-  function visit(value) {
-    if (Array.isArray(value)) {
-      value.forEach(visit);
-      return;
-    }
-    if (!value || typeof value !== 'object') {
-      return;
-    }
-    const componentName = normalizeFormDefinitionType(value);
-    if (isSupportedBusinessFieldType(componentName)) {
-      output.push(value);
-      if (!verifyNestedFields) {
-        return;
-      }
-    }
-    if (Array.isArray(value.children)) {
-      value.children.forEach(visit);
-    }
-  }
-
-  visit(fields);
-  return output;
-}
-
-function isRecoverableBlankResumeSchema(schema) {
-  const allowedShellComponents = new Set(['Page', 'RootHeader', 'RootContent', 'RootFooter', 'FooterYida']);
-  const componentsTree = schema && schema.pages && schema.pages[0] && schema.pages[0].componentsTree;
-  if (!Array.isArray(componentsTree) || componentsTree.length === 0) {
-    return true;
-  }
-  let safe = true;
-  function visit(node) {
-    if (!node || typeof node !== 'object' || !safe) {
-      return;
-    }
-    if (node.componentName && !allowedShellComponents.has(node.componentName)) {
-      safe = false;
-      return;
-    }
-    if (Array.isArray(node.children)) {
-      node.children.forEach(visit);
-    }
-  }
-  componentsTree.forEach(visit);
-  return safe;
-}
-
-function buildResumeChanges(existingFields, desiredFields) {
-  const existingByLabel = new Map();
-  existingFields.forEach(function (field) {
-    const bucket = existingByLabel.get(field.label) || [];
-    bucket.push(field);
-    existingByLabel.set(field.label, bucket);
-  });
-
-  const desiredLabels = new Set();
-  const missing = [];
-  const existing = [];
-  const conflicts = [];
-  desiredFields.forEach(function (field) {
-    const identity = desiredResumeFieldIdentity(field);
-    if (!identity.label || desiredLabels.has(identity.label)) {
-      conflicts.push({
-        code: identity.label ? 'CREATE_FORM_RESUME_DUPLICATE_DESIRED_FIELD' : 'CREATE_FORM_RESUME_FIELD_LABEL_REQUIRED',
-        label: identity.label || null,
-      });
-      return;
-    }
-    desiredLabels.add(identity.label);
-    const matches = existingByLabel.get(identity.label) || [];
-    if (matches.length === 0) {
-      missing.push(field);
-      return;
-    }
-    if (matches.length !== 1 || matches[0].componentName !== identity.componentName) {
-      conflicts.push({
-        code: 'CREATE_FORM_RESUME_FIELD_CONFLICT',
-        label: identity.label,
-        requestedType: identity.componentName,
-        observedTypes: matches.map(function (item) { return item.componentName; }),
-      });
-      return;
-    }
-    existing.push({
-      label: identity.label,
-      componentName: identity.componentName,
-      fieldId: matches[0].fieldId,
-    });
-  });
-  return { missing, existing, conflicts };
-}
-
-async function readResumeSchema(authRef, appType, formUuid) {
-  const schemaResult = await requestWithAutoLogin(function (auth) {
-    return sendGetRequest(
-      auth.baseUrl,
-      buildApiPath(appType, 'getFormSchema', { prefix: '_view', namespace: 'alibaba' }),
-      { formUuid: formUuid, schemaVersion: 'V5' }
-    );
-  }, authRef);
-  if (!schemaResult || schemaResult.success === false || schemaResult.__needLogin || schemaResult.__csrfExpired) {
-    throwCreateFormError(t('create_form.resume_readback_failed'), 'CREATE_FORM_RESUME_READBACK_FAILED', {
-      appType,
-      formUuid,
-      result: sanitizeFailureResult(schemaResult),
-    });
-  }
-  if (schemaResult.appType && schemaResult.appType !== appType) {
-    throwCreateFormError(t('create_form.resume_ownership_unverified'), 'CREATE_FORM_RESUME_OWNERSHIP_UNVERIFIED', {
-      appType,
-      formUuid,
-    });
-  }
-  if (schemaResult.formUuid && schemaResult.formUuid !== formUuid) {
-    throwCreateFormError(t('create_form.resume_identity_mismatch'), 'CREATE_FORM_RESUME_OWNERSHIP_UNVERIFIED', {
-      appType,
-      formUuid,
-    });
-  }
-  const schema = schemaResult.content
-    ? (typeof schemaResult.content === 'string' ? JSON.parse(schemaResult.content) : schemaResult.content)
-    : schemaResult.pages ? schemaResult : null;
-  if (!schema || !Array.isArray(schema.pages) || schema.pages.length === 0) {
-    throwCreateFormError(t('create_form.resume_schema_invalid'), 'CREATE_FORM_RESUME_SCHEMA_INVALID', {
-      appType,
-      formUuid,
-    });
-  }
-  return { schemaResult, schema, version: extractSchemaServerRevision(schemaResult) };
-}
-
-async function mainResume(parsedArgs, authRef) {
-  const { appType, formUuid, fieldsJsonOrFile } = parsedArgs;
-  assertNoEmojiInDefinitionFileName(fieldsJsonOrFile);
-  const { fields, validations } = readFieldsDefinition(fieldsJsonOrFile);
-  assertNoEmojiInFormDefinition(formUuid, fields, [], 'create-form resume input');
-  validateFormFieldDefinitions(fields);
-
-  const firstRead = await readResumeSchema(authRef, appType, formUuid);
-  const root = firstRead.schema.pages[0].componentsTree && firstRead.schema.pages[0].componentsTree[0];
-  const formContainer = root ? findFormContainer(root) : null;
-  const completedStages = ['read_target', 'verify_ownership'];
-  let recoveredBlankShell = false;
-  let plan;
-
-  if (!formContainer) {
-    if (!isRecoverableBlankResumeSchema(firstRead.schema)) {
-      throwCreateFormError(t('create_form.resume_container_invalid'), 'CREATE_FORM_RESUME_SCHEMA_INVALID', {
-        appType,
-        formUuid,
-        retryable: false,
-        remoteWrites: 0,
-      });
-    }
-    const corpId = resolveCorpId(authRef.authData);
-    const formTitle = firstRead.schemaResult.formTitle || firstRead.schemaResult.title || formUuid;
-    firstRead.schema = buildFormSchema(formTitle, fields, formUuid, corpId, appType, 'single', 'default', 'top');
-    const resumeValidationRules = collectSmartValidationRulesFromFields(fields).concat(validations || []);
-    if (resumeValidationRules.length > 0) {
-      applySmartValidations(firstRead.schema, resumeValidationRules);
-    }
-    await saveFormSchema(authRef, appType, formUuid, firstRead.schema, firstRead.version, 4);
-    completedStages.push('rebuild_blank_schema', 'save_schema');
-    recoveredBlankShell = true;
-    plan = {
-      existing: [],
-      missing: collectResumeDesiredFields(fields, { verifyNestedFields: true }),
-      conflicts: [],
-    };
-  } else if (!Array.isArray(formContainer.children)) {
-    throwCreateFormError(t('create_form.resume_container_invalid'), 'CREATE_FORM_RESUME_SCHEMA_INVALID', {
-      appType,
-      formUuid,
-      retryable: false,
-      remoteWrites: 0,
-    });
-  } else {
-    plan = buildResumeChanges(
-      collectResumeFieldEvidence(formContainer.children),
-      collectResumeDesiredFields(fields)
-    );
-    if (plan.conflicts.length > 0) {
-      throwCreateFormError(t('create_form.resume_field_conflict'), 'CREATE_FORM_RESUME_CONFLICT', {
-        appType,
-        formUuid,
-        retryable: false,
-        remoteWrites: 0,
-        diagnostics: plan.conflicts,
-      });
-    }
-    completedStages.push('compare_fields');
-  }
-
-  if (!recoveredBlankShell && plan.missing.length > 0) {
-    const applied = applyChangesToSchema(
-      firstRead.schema,
-      plan.missing.map(function (field) { return { action: 'add', field }; }),
-      { verbose: true }
-    );
-    if ((applied.diagnostics || []).length > 0) {
-      throwCreateFormError(t('create_form.resume_field_resolution_failed'), 'CREATE_FORM_RESUME_CONFLICT', {
-        appType,
-        formUuid,
-        retryable: false,
-        remoteWrites: 0,
-        diagnostics: applied.diagnostics,
-      });
-    }
-    const corpId = resolveCorpId(authRef.authData);
-    const updatedContainer = findFormContainer(firstRead.schema.pages[0].componentsTree[0]);
-    fillSerialNumberFormulas(updatedContainer.children, corpId, appType, formUuid);
-    await saveFormSchema(authRef, appType, formUuid, firstRead.schema, firstRead.version, 4);
-    completedStages.push('add_missing_fields', 'save_schema');
-  }
-
-  const finalRead = await readResumeSchema(authRef, appType, formUuid);
-  const finalContainer = findFormContainer(finalRead.schema.pages[0].componentsTree[0]);
-  const finalPlan = buildResumeChanges(
-    collectResumeFieldEvidence(finalContainer && finalContainer.children),
-    collectResumeDesiredFields(fields, { verifyNestedFields: true })
-  );
-  if (finalPlan.missing.length > 0 || finalPlan.conflicts.length > 0) {
-    throwCreateFormError(t('create_form.resume_readback_mismatch'), 'CREATE_FORM_RESUME_READBACK_MISMATCH', {
-      appType,
-      formUuid,
-      retryable: false,
-      resultUnknown: true,
-      completedStages,
-      missingFieldCount: finalPlan.missing.length,
-      diagnostics: finalPlan.conflicts,
-    });
-  }
-  completedStages.push('verify_final_schema');
-  const formUrl = authRef.baseUrl + '/' + appType + '/workbench/' + formUuid;
-  const output = {
-    success: true,
-    appType,
-    formUuid,
-    completedStages,
-    requestedFieldCount: fields.length,
-    existingFieldCount: plan.existing.length,
-    addedFieldCount: plan.missing.length,
-    finalFieldCount: collectResumeFieldEvidence(finalContainer.children).length,
-    recoveredBlankShell,
-    url: formUrl,
-  };
-  console.log(JSON.stringify(withBrowserHandoff(
-    output,
-    formUrl,
-    { stage: 'resume_form_success', title: formUuid },
-    parsedArgs.browserOpenMode
-  )));
-  return output;
-}
-
 async function mainUpdate(parsedArgs, authRef) {
   const { appType, formUuid, changesJsonOrFile } = parsedArgs;
 
@@ -6393,7 +6102,6 @@ async function run(args) {
     {
       create: mainCreate,
       update: mainUpdate,
-      resume: mainResume,
       patch: mainPatch,
       rule: mainRule,
       validation: mainValidation,

package/lib/core/command-manifest.js

@@ -449,7 +449,6 @@ const COMMAND_SIDE_EFFECTS = new Map([
     'create-form.bind-datasource',
     'create-form.create',
     'create-form.patch',
-    'create-form.resume',
     'create-form.rule',
     'create-form.update',
     'create-form.validation',
@@ -690,7 +689,6 @@ const COMMAND_PERMISSIONS = new Map([
     'create-form.create',
     'create-form.batch',
     'create-form.patch',
-    'create-form.resume',
     'create-form.rule',
     'create-form.update',
     'create-form.validation',
@@ -1225,8 +1223,7 @@ const COMMAND_GROUPS = [
       command('create-form.validate-fields', ['create-form', 'validate-fields'], 'create-form validate-fields <fieldsJsonOrFile> [--json]', 'help.cmd_validate_form', {
         requiresLogin: false,
       }),
-      command('create-form.update', ['create-form', 'update'], 'create-form update <appType> <formUuid> (<changesJsonOrFile> | --data-file <changesJsonOrFile>) [--locale zh_CN|en_US|ja_JP] [--open|--no-open]', 'help.cmd_update_form'),
-      command('create-form.resume', ['create-form', 'resume'], 'create-form resume <appType> <formUuid> <fieldsJsonOrFile> [--json]', 'help.cmd_update_form'),
+      command('create-form.update', ['create-form', 'update'], 'create-form update <appType> ... [--locale zh_CN|en_US|ja_JP] [--open|--no-open]', 'help.cmd_update_form'),
       command('create-form.patch', ['create-form', 'patch'], 'create-form patch <appType> <formUuid> <patchJsonOrFile> [--open|--no-open]', 'help.cmd_update_form'),
       command('create-form.rule', ['create-form', 'rule'], 'create-form rule <appType> <formUuid> <rulesJsonOrFile> [--open|--no-open]', 'help.cmd_update_form'),
       command('create-form.validation', ['create-form', 'validation'], 'create-form validation <appType> <formUuid> <validationsJsonOrFile> [--open|--no-open]', 'help.cmd_update_form'),

package/lib/core/locales/en.js

@@ -827,15 +827,7 @@ Examples:
     example_update: 'Example: openyida create-form update "APP_XXX" "FORM-YYY" \'[{"action":"add","field":{"type":"TextField","label":"Note"}}]\'',
     usage_label: 'Usage:',
     usage_create_short: '  create: openyida create-form create <appType> <formTitle> <fieldsJsonFile>',
-    usage_update_short: '  update: openyida create-form update <appType> <formUuid> <changesJsonOrFile> or --data-file <changesJsonOrFile>',
-    resume_readback_failed: 'Unable to read the target form before resume.',
-    resume_ownership_unverified: 'The target form does not belong to the requested app; resume stopped.',
-    resume_identity_mismatch: 'The target form identity does not match the readback; resume stopped.',
-    resume_schema_invalid: 'The target form schema is unavailable.',
-    resume_container_invalid: 'The target form container is unavailable.',
-    resume_field_conflict: 'Existing fields conflict with the requested definition; resume stopped.',
-    resume_field_resolution_failed: 'Resume field resolution failed.',
-    resume_readback_mismatch: 'Resume readback did not confirm all requested fields.',
+    usage_update_short: '  update: openyida create-form update <appType> <formUuid> <changesJsonOrFile>',
     example_label: '\nExamples:',
     fields_file_not_found: '  ❌ Fields definition file not found: ',
     fields_format_invalid: 'Invalid fields definition format',

package/lib/core/locales/zh.js

@@ -798,15 +798,7 @@ openyida - 宜搭命令行工具
     example_update: '示例：openyida create-form update "APP_XXX" "FORM-YYY" \'[{"action":"add","field":{"type":"TextField","label":"备注"}}]\'',
     usage_label: '用法:',
     usage_create_short: '  创建: openyida create-form create <appType> <formTitle> <fieldsJsonFile>',
-    usage_update_short: '  更新: openyida create-form update <appType> <formUuid> <changesJsonOrFile> 或 --data-file <changesJsonOrFile>',
-    resume_readback_failed: '恢复前无法回读目标表单。',
-    resume_ownership_unverified: '目标表单不属于指定应用，已停止恢复。',
-    resume_identity_mismatch: '目标表单身份与回读结果不一致，已停止恢复。',
-    resume_schema_invalid: '目标表单 Schema 不可用。',
-    resume_container_invalid: '目标表单容器不可用。',
-    resume_field_conflict: '已有字段与请求定义冲突，恢复已停止。',
-    resume_field_resolution_failed: '恢复字段解析失败。',
-    resume_readback_mismatch: '恢复后的回读未确认全部请求字段。',
+    usage_update_short: '  更新: openyida create-form update <appType> <formUuid> <changesJsonOrFile>',
     example_label: '\n示例:',
     fields_file_not_found: '  ❌ 字段定义文件不存在: ',
     fields_format_invalid: '字段定义格式不正确',

package/lib/process/configure-process.js

@@ -361,12 +361,7 @@ async function run(args, options) {
       error.code || 'CONFIGURE_PROCESS_BUILD_FAILED',
       t('configure_process.building_json') + ': ' + error.message,
       'build_definition',
-      error,
-      {
-        retryable: false,
-        nextAction: 'fix_definition_file',
-        diagnostics: [summarizeRemoteResult(error)],
-      }
+      error
     );
   }
   stageTracker.complete('build_definition');
@@ -429,18 +424,6 @@ async function run(args, options) {
           remoteWrites: 0,
           published: !!versionState.published,
           saved: !!versionState.saved,
-          retryable: false,
-          requiresExplicitReplace: true,
-          nextAction: 'request_confirmation_then_replace',
-          suggestedCommand: [
-            'openyida configure-process',
-            appType,
-            formUuid,
-            processDefinitionFile,
-            processCode,
-            '--replace',
-            '--json',
-          ].filter(Boolean).join(' '),
         }
       );
     }

package/package.json

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

package/yida-skills/skills/yida-app/workflow/plan/step-4-deliver.md

@@ -34,9 +34,9 @@ HTML 保留“需求总览、数据模型、业务流程、页面规划”四章
 
 按 [用户交互契约](../../../yida-design/references/ask-human-interaction-contract.md) 执行：
 
-1. 在会话中展示“当前这版方案”，并用 3–7 条业务摘要说明方案内容。
-2. 通过同一次结构化提问的 `attachments` 携带可打开的 `prd/<项目名>/build-plan.html`，并将 `revision` 设为当前 `meta.revision`；不得先发普通文本附件、再单独提问。
-3. 结构化交互成功创建后内部记录 `presentedRevision=meta.revision`。询问“确认并开始搭建”或“继续调整”，提交时由宿主原样回传 revision，将确认结果绑定到本次展示版本；收到确认或修改业务事实后再重新生成。用户可见版本称为“第 N 版方案”，展示序号与内部 revision 绑定。
+1. 在会话中展示“当前这版方案”、3–7 条业务摘要和可打开的 `build-plan.html`。
+2. 展示成功后内部记录 `presentedRevision=meta.revision`，记录后直接提问；收到确认或修改业务事实后再重新生成。用户可见版本称为“第 N 版方案”，展示序号与内部 revision 绑定。
+3. 询问“确认并开始搭建”或“继续调整”，将确认结果绑定到本次展示版本。
 
 只有以下条件同时成立才交接：
 

package/yida-skills/skills/yida-app/workflow/step-4-forms-processes.md

@@ -1,6 +1,6 @@
 # Step 4：创建或更新表单/流程
 
-按 PRD 的依赖创建或复用表单和流程。同一轮需要新建两个及以上普通表单时，把独立表单和关联表单写入同一个 `forms.json`，通过 `dependsOn` / `$form` 表达依赖，并且只调用一次 `openyida create-form batch`；由 CLI 内部完成分组、真实 ID 回读和依赖调度，不逐个 create，也不由模型拆成多次 batch。某页所需表单、流程就绪后即可接入该页；不要因其他页面的资源未完成而阻塞无依赖页面开发。
+按 PRD 的依赖创建或复用表单和流程。独立普通表单通过 [批量命令](../../yida-create-form-page/references/batch-forms.md) 同时创建；关联表单等待前置表单完成。某页所需表单、流程就绪后即可接入该页；不要因其他页面的资源未完成而阻塞无依赖页面开发。
 
 拿到真实 `appType` 和已确认的业务契约即可开始本步骤，不等待主题 CSS 上传或应用主题设置回读。主题分支与本步骤并行，按 [主题与业务资源的依赖](parallel-work.md#主题与业务资源的依赖) 汇合。
 
@@ -15,7 +15,7 @@
 
 1. 执行 `use_skill("yida-create-form-page", "创建或更新核心表单字段结构")`，创建或更新普通表单字段结构。
 2. 已有目标表单时，使用 update/patch/rule/bind-datasource。
-3. 缺少支撑 MVP 的核心普通表单且允许创建时，按上述单批次契约创建；只有一个新表单或 batch 契约无法表达当前依赖时才使用单表单 create，并说明原因。
+3. 缺少支撑 MVP 的核心普通表单且允许创建时，创建普通表单。
 4. 字段配置文件写入 `.cache/openyida/<项目名>/`。
 5. 拿到真实 `formUuid` 后写入资源上下文。
 6. 批量创建返回的字段映射直接复用。其他页面、数据、流程或公式确需多字段映射时，对每个目标表单最多一次性执行 `openyida get-schema <appType> <formUuid> --field-map-json`，合并写回 `.cache/<项目名>-schema.json`。

package/yida-skills/skills/yida-app/workflow/step-9-output-finish.md

@@ -14,8 +14,6 @@
 - 页面/资源数量完整性风险检查结果。
 - `requirement-brief.json.constraints.prohibitedActions` 与对应跳过证据。
 
-主入口与页面入口必须取自本轮 CLI 成功结果返回的 `appUrl`、`workbenchUrl` 或 `url`，并在后续只读回查中保持一致。不得由模型根据 `appType` 自行拼接或猜测链接；下文 URL 规则仅用于校验服务端/CLI 返回值，不是缺失链接时的生成规则。若成功结果没有权威 URL，必须明确交付失败并执行只读回查，不能交付空卡片或用模板补齐。
-
 ## 完成条件核对
 
 完整应用默认完成需要同时满足：

package/yida-skills/skills/yida-create-form-page/SKILL.md

@@ -58,7 +58,7 @@ description: 表单页面创建与更新；支持 19 种业务字段和 Divider
 
 ## 多表单创建
 
-同一轮需要新建两个及以上普通表单时，必须按 [并行创建表单](references/batch-forms.md) 把全部表单写入同一个 `forms.json`，并且只调用一次 `openyida create-form batch <appType> <任务文件> --json`。独立表单和关联表单放在同一任务文件中，依赖通过 `dependsOn` / `$form` 表达，由 CLI 在一次 batch 内部完成分组、真实 `formUuid/fieldId` 回读和依赖调度；不要手工拆成多次 batch，也不要逐个调用 `create-form create`。只有修改已有表单、恢复已有 `formUuid`，或当前 batch 契约无法表达依赖时，才走明确的非 batch 路径并说明原因。
+多个普通表单按 [并行创建表单](references/batch-forms.md) 准备任务，执行 `openyida create-form batch <appType> <任务文件> --json`。CLI 同时创建独立表单，等待关联表单与真实字段就绪后创建依赖表单。
 
 ## 官方表单示例范式
 
@@ -118,7 +118,7 @@ openyida create-form create <appType> <formTitle> <fieldsJsonOrFile> [--layout d
 # 文件路径示例：.cache/openyida/<项目名或任务名>/<表单名>-fields.json
 ```
 
-默认不传 `--icon`，由 CLI 根据表单标题和字段语义选择导航图标，再更新导航节点并回读校验。只有用户明确指定某个图标时才传 `--icon <iconName>`；普通搭建不得调用 `openyida create-form icons` 枚举候选，也不得先猜图标、失败后再探索。`icons` 仅供用户明确指定但值不合法时的人工诊断。表单导航图标是纯图标名（如 `name-card`、`Project`、`Todo`、`clock`），不是应用图标的 `xian-*%%color` 协议。
+创建成功后 CLI 会根据表单标题和字段语义选择导航图标，再更新导航节点并回读校验。需要指定时传 `--icon <iconName>`；用 `openyida create-form icons --json` 查看与 yida-next 页面导航选择器一致的 86 个可用值。表单导航图标是纯图标名（如 `name-card`、`Project`、`Todo`、`clock`），不是应用图标的 `xian-*%%color` 协议。
 
 导航图标更新必须先读取 `getFormNavigationListByOrder.json` 的当前节点，像 yida-next 的 `DB.Nav.update({ ...node, title: JSON.stringify(node.title), formUuid: node.formUuid || 'NAV-SYSTEM-FROM-ME-UUID', icon })` 一样保留 `gmtModified`、`formType`、`isNewForm`、`listOrder` 等原值，再请求带 `_api=Nav.update&_mock=false&_stamp=...` 的 `updateFormNavigation.json`，最后重新读取导航列表校验图标。禁止仅凭 formUuid 拼一个精简更新 payload。
 
@@ -142,7 +142,7 @@ openyida create-form create <appType> <formTitle> <fieldsJsonOrFile> [--layout d
 create 命令失败后，不要立刻重复同一条 create：
 
 1. 先确认字段 JSON 文件存在，且内容是结构化写入后的最终字段数组/对象，不是半截 JSON、update changes 或 shell 拼接残留。
-2. 运行 `openyida list-forms <appType> --keyword "<表单名>"` 查同名表单；若失败结果已给出本轮创建的 `formUuid`，使用 `openyida create-form resume <appType> <formUuid> <fieldsJsonOrFile> --json` 先回读、比较并仅补缺失字段。冲突或结果未知时停止，不能重新 create；普通已知修改仍用 `update` / `patch`。
+2. 运行 `openyida list-forms <appType> --keyword "<表单名>"` 查同名表单；若本轮刚创建过空白表单或已有同名目标表单，优先走 `create-form update` / `patch` / 后续显式 resume 能力复用，不再 create。
 3. 只有确认远端没有同名目标表单，并且已经修改输入文件、参数、登录态或组织后，才重试 create。
 4. 同一 create 命令最多重试 2 次；仍失败时停止并带上完整 stdout/stderr、字段文件路径、appType、表单名和已发现的 formUuid 给用户。
 
@@ -152,23 +152,9 @@ create 命令失败后，不要立刻重复同一条 create：
 
 ```bash
 openyida create-form update <appType> <formUuid> <changesJsonOrFile>
-openyida create-form update <appType> <formUuid> --data-file <changesJsonOrFile>
 # 文件路径示例：.cache/openyida/<项目名或任务名>/<表单名>-changes.json
 ```
 
-位置参数和 `--data-file` 是同一输入的两种写法，不能同时使用。
-
-## 半成功 create 恢复
-
-create 已返回真实 `formUuid`、但后续 schema 保存或回读失败时，使用保守恢复命令：
-
-```bash
-openyida create-form resume <appType> <formUuid> <fieldsJsonOrFile> --json
-```
-
-该命令先回读目标表单并核对字段，只添加可唯一判定的缺失字段，保存后再次回读；同名异类型、重复
-目标字段、归属不匹配或回读不确定时均停止且不写入。它不会新建替代表单，也不会覆盖已有字段。
-
 输出：
 
 ```json

package/yida-skills/skills/yida-design/references/ask-human-interaction-contract.md

@@ -115,13 +115,6 @@ Fast / Plan 是面向用户的模式名称，可以展示。已有详细计划
 - `allowCustom`：是否允许用户补充自定义答案。
 - `writeBackPath`：答案写回位置。
 
-需要让用户查看 workspace 产物后再回答时，同一次 `ask_human` 还必须携带：
-
-- `attachments`：待查看文件列表；workspace 文件使用 `{ "name": "搭建方案", "path": "prd/<项目名>/build-plan.html" }`。路径必须位于当前项目工作区，不能传运行时内部路径或外部绝对路径。
-- `revision`：本次问题绑定的事实版本。宿主提交回答时必须原样回传；版本已变化时拒绝旧回答并重新展示最新版本。
-
-附件、问题与 `revision` 是一个原子交互。不得先发普通文本附件、再单独调用 `ask_human`，也不得只在问题文案中写文件路径；否则实时界面和历史回放无法可靠证明用户确认的是哪一版方案。
-
 ## 首次搭建确认
 
 先完成需求分析，再按 [首次搭建确认表](../../yida-requirement-analysis/workflow/prepare-brief.md#2-确认首次搭建的未决事项) 询问尚未明确的事项。该表统一维护详细计划复用、搭建方式、业务模块、导航归属与布局、风格和页面范围；已有业务应用的局部增改按本次疑问澄清。
@@ -135,9 +128,9 @@ Fast / Plan 是面向用户的模式名称，可以展示。已有详细计划
 Plan Design 完成当前版本后，按以下顺序与用户交互：
 
 1. 在会话中使用“当前这版方案”或“第 N 版方案”，给出 3-7 条业务摘要；原始 `meta.revision` 仅用于内部状态绑定。
-2. 在“最新搭建计划确认”的同一次 `ask_human` 中，通过 `attachments` 展示可打开的 `prd/<项目名>/build-plan.html`，并以 `revision` 绑定当前 `meta.revision`。
-3. 结构化交互成功创建后令 `meta.planState.presentedRevision` 等于 `meta.revision`；awaiting_confirmation 在生成前写入。
-4. 提供“确认并开始搭建”和“继续调整”两个选择，并等待用户回答。
+2. 以宿主支持的文件链接、附件或可打开产物形式展示 `prd/<项目名>/build-plan.html`。
+3. 展示成功后令 `meta.planState.presentedRevision` 等于 `meta.revision`；awaiting_confirmation 在生成前写入，展示记账完成后继续询问。
+4. 执行“最新搭建计划确认”类型的 `ask_human`，提供“确认并开始搭建”和“继续调整”两个选择。
 
 `build-plan.html` 不承载对话控件或确认按钮；用户在会话中完成确认。
 
@@ -162,14 +155,7 @@ Plan Design 完成当前版本后，按以下顺序与用户交互：
     }
   ],
   "allowCustom": false,
-  "writeBackPath": "meta.planState",
-  "attachments": [
-    {
-      "name": "当前搭建方案",
-      "path": "prd/<项目名>/build-plan.html"
-    }
-  ],
-  "revision": "{revision}"
+  "writeBackPath": "meta.planState"
 }
 ```