@lingjingai/lj-awb-cli-pre 0.3.17 → 0.3.18

package/README.md

@@ -39,7 +39,7 @@ export LINGJING_AWB_API_ORIGIN=https://animeworkbench.lingjingai.cn
 export LINGJING_AWB_ACCESS_KEY=<access_key>
 ```
 
-兼容的 access key 变量：`LINGJING_AWB_ACCESS_KEY`、`AWB_ACCESS_KEY`、`AWB_CODE`、`ANIME_ACCESS_KEY`。
+`lj-awb` 只读取 `LINGJING_AWB_ACCESS_KEY` 作为环境变量 access key。
 
 ## 安装与运行
 
@@ -80,13 +80,13 @@ macOS 本地 wrapper `packages/awb-cli/bin/lj-awb` 会自动补充 Node 证书
 保存 access key 到本地认证文件：
 
 ```bash
-lj-awb auth login-key --access-key <access_key>
+lj-awb auth login --access-key <access_key>
 ```
 
 从环境变量读取并保存：
 
 ```bash
-LINGJING_AWB_ACCESS_KEY=<access_key> lj-awb auth login-key --from-env
+LINGJING_AWB_ACCESS_KEY=<access_key> lj-awb auth login
 ```
 
 不落盘，直接让每次调用读取环境变量：
@@ -244,7 +244,7 @@ lj-awb create video \
 
 ## JSON 输出契约
 
-默认输出是 compact text，适合终端和 Agent 低 token 读取；只有需要完整嵌套结构、稳定 JSON envelope 或脚本严格解析时才追加 `-f json` 或 `--json`。`schema` 通常使用 JSON；`model options` 和 `model create-spec` 默认 text 先读，必要时再切 JSON。
+默认输出是 compact text，适合终端和 Agent 低 token 读取；复杂模型命令使用 `section:` + 缩进 `key=value` 的分区格式，避免 `params`、`resources`、`intents`、`next` 混在一屏里。只有需要完整嵌套结构、稳定 JSON envelope 或脚本严格解析时才追加 `-f json` 或 `--json`。`schema` 通常使用 JSON；`model options` 和 `model create-spec` 默认 text 先读，必要时再切 JSON。
 
 输出字段只保留后续动作不可替代的信息。默认不返回平台原始 `raw`、COS 签名细节、重复的首个结果字段；任务结果统一使用 `resultUrls` 表达。
 
@@ -270,7 +270,7 @@ lj-awb create video \
   "error": {
     "type": "auth_required",
     "message": "缺少 access key",
-    "hint": "请设置 LINGJING_AWB_ACCESS_KEY / AWB_ACCESS_KEY，或运行 lj-awb auth login-key。"
+    "hint": "请设置 LINGJING_AWB_ACCESS_KEY，或运行 lj-awb auth login。"
   },
   "meta": {
     "command": "account info",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingjingai/lj-awb-cli-pre",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Lingjing AWB CLI monorepo with shared core, standalone CLI, and agent skills (pre-release build pointing to https://animeworkbench-pre.lingjingai.cn)",
   "license": "MIT",
   "type": "module",

package/packages/awb-cli/README.md

@@ -13,7 +13,4 @@ node bin/lj-awb.js auth status -f json
 
 ```bash
 export LINGJING_AWB_ACCESS_KEY=<access_key>
-# 兼容 AWB 既有变量：
-export AWB_ACCESS_KEY=<access_key>
-export AWB_CODE=<access_key>
 ```

package/packages/awb-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingjingai/awb-cli-bin",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Standalone CLI for Lingjing AWB",
   "private": true,
   "license": "MIT",
@@ -13,6 +13,6 @@
     "README.md"
   ],
   "dependencies": {
-    "@lingjingai/awb-core": "0.3.17"
+    "@lingjingai/awb-core": "0.3.18"
   }
 }

package/packages/awb-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lingjingai/awb-core",
-  "version": "0.3.17",
+  "version": "0.3.18",
   "description": "Shared core runtime for Lingjing AWB CLI",
   "license": "MIT",
   "type": "module",

package/packages/awb-core/src/auth.js

@@ -37,7 +37,7 @@ export async function resolveAuthContext({ required = true } = {}) {
     throw new LingjingAwbCliError('缺少 access key', {
       type: 'auth_required',
       exitCode: 3,
-      hint: '请设置 LINGJING_AWB_ACCESS_KEY / AWB_ACCESS_KEY，或运行 lj-awb auth login。',
+      hint: '请设置 LINGJING_AWB_ACCESS_KEY，或运行 lj-awb auth login。',
     });
   }
   return {

package/packages/awb-core/src/commands.js

@@ -169,7 +169,7 @@ export function registerAwbCommands(cli) {
         'LINGJING_AWB_ACCESS_KEY=<key> lj-awb auth login',
         'lj-awb auth login --access-key <key> --skip-verify',
       ],
-      hint: '不要写成 lj-awb auth <key>。不传 --access-key 时自动读取 LINGJING_AWB_ACCESS_KEY / AWB_ACCESS_KEY / AWB_CODE 环境变量。',
+      hint: '不要写成 lj-awb auth <key>。不传 --access-key 时只读取 LINGJING_AWB_ACCESS_KEY 环境变量。',
     }),
     args: [
       { name: 'access-key', valueName: 'key', description: '平台 access key；不传时读取环境变量' },
@@ -178,7 +178,7 @@ export function registerAwbCommands(cli) {
     ],
     func: async (_ctx, kwargs) => {
       const skipVerify = toBool(kwargs.skipVerify);
-      const accessKey = trimSecret(kwargs.accessKey || process.env.LINGJING_AWB_ACCESS_KEY || process.env.AWB_ACCESS_KEY || process.env.AWB_CODE || process.env.ANIME_ACCESS_KEY || '');
+      const accessKey = trimSecret(kwargs.accessKey || process.env.LINGJING_AWB_ACCESS_KEY || '');
       if (!accessKey) {
         throw new LingjingAwbCliError('缺少 access key', {
           type: 'argument_error',

package/packages/awb-core/src/common.js

@@ -14,7 +14,7 @@ export const API_ORIGIN = (
 export const APP_HOME_DIR = process.env.LINGJING_AWB_STATE_DIR || process.env.ANIME_STATE_DIR || path.join(os.homedir(), '.lingjingai', 'awb');
 export const AUTH_PATH = process.env.LINGJING_AWB_AUTH_PATH || process.env.ANIME_AUTH_PATH || path.join(APP_HOME_DIR, 'auth.json');
 export const STATE_PATH = process.env.LINGJING_AWB_STATE_PATH || process.env.ANIME_STATE_PATH || path.join(APP_HOME_DIR, 'state.json');
-export const ACCESS_KEY_ENV_NAMES = ['LINGJING_AWB_ACCESS_KEY', 'AWB_ACCESS_KEY', 'AWB_CODE', 'ANIME_ACCESS_KEY'];
+export const ACCESS_KEY_ENV_NAMES = ['LINGJING_AWB_ACCESS_KEY'];
 export const TASK_UPLOAD_SCENE = {
   IMAGE_CREATE: 'material-image-draw',
   IMAGE_EDIT: 'material-image-edit',

package/packages/awb-core/src/output.js

@@ -681,6 +681,42 @@ function renderRecord(record, preferredKeys = [], excludedKeys = []) {
   return keys.map((key) => `${key}=${shortValue(record[key])}`).join(' ');
 }
 
+function recordScalarKeys(record, preferredKeys = [], excludedKeys = []) {
+  const excluded = new Set(excludedKeys);
+  return [
+    ...preferredKeys.filter((key) => !excluded.has(key) && record[key] !== undefined),
+    ...Object.keys(record).filter((key) => !excluded.has(key) && !preferredKeys.includes(key) && !Array.isArray(record[key]) && !isPlainObject(record[key])),
+  ];
+}
+
+function pushSectionRecord(lines, title, record, preferredKeys = []) {
+  const compacted = compactRecord(record);
+  lines.push(`${title}:`);
+  for (const key of recordScalarKeys(compacted, preferredKeys)) {
+    lines.push(`  ${key}=${shortValue(compacted[key])}`);
+  }
+}
+
+function pushSectionCount(lines, title, count) {
+  lines.push(`${title}:`);
+  lines.push(`  count=${count}`);
+}
+
+function pushSectionKeyValue(lines, key, value) {
+  if (value === undefined || value === null || value === '') return;
+  lines.push(`  ${key}=${value}`);
+}
+
+function pushSectionItem(lines, index, value) {
+  if (value === undefined || value === null || value === '') return;
+  lines.push(`  [${index}]=${value}`);
+}
+
+function pushSectionRecordItem(lines, index, record, preferredKeys = []) {
+  const rendered = renderRecord(compactRecord(record), preferredKeys);
+  if (rendered) lines.push(`  [${index}]: ${rendered}`);
+}
+
 function firstList(data) {
   for (const [key, value] of Object.entries(data || {})) {
     if (['resultUrls', 'originUrls'].includes(key)) continue;
@@ -925,70 +961,71 @@ function formatModelOptionsOutput(data = {}) {
   const resources = Array.isArray(data.resources) ? data.resources : [];
   const constraints = Array.isArray(data.constraints) ? data.constraints : [];
   const lines = ['ok model options'];
-  lines.push(renderRecord(compactRecord({
+  pushSectionRecord(lines, 'summary', {
     modelGroupCode: data.modelGroupCode,
     taskKind: data.taskKind,
-  }), ['modelGroupCode', 'taskKind']));
-  lines.push(`params.count=${params.length}`);
+  }, ['modelGroupCode', 'taskKind']);
+  pushSectionCount(lines, 'params', params.length);
   for (const [index, param] of params.entries()) {
-    lines.push(`param[${index}]: ${renderRecord(compactRecord({
+    pushSectionRecordItem(lines, index, {
       key: param.key,
       type: param.valueType,
       values: valueList(param.values),
       default: param.defaultValue,
       maxLength: param.maxLength,
       required: param.required,
-    }), ['key', 'type', 'values', 'default', 'maxLength', 'required'])}`);
+    }, ['key', 'type', 'values', 'default', 'maxLength', 'required']);
   }
-  if (resources.length) {
-    lines.push(`resources.count=${resources.length}`);
-    for (const [index, item] of resources.entries()) {
-      lines.push(`resource[${index}]: ${renderRecord(compactRecord({
-        mode: item.mode,
-        media: item.mediaType,
-        usage: item.usage,
-        valueShapes: textValueShapes(item.valueShapes),
-        formats: textResourceFormats(item),
-        webpInput: textWebpInput(item),
-        autoConvert: textResourceAutoConvert(item),
-        files: textFileCount(item),
-        maxSizeKB: item.maxSizeKB,
-        durationMs: textDurationRange(item),
-        totalDurationMs: item.maxTotalDurationMs != null ? `<=${item.maxTotalDurationMs}` : undefined,
-        items: textItemCount(item),
-        maxPromptLength: item.maxPromptLength,
-        lastFrameOnly: item.supportLastFrameOnly,
-      }), [
-        'mode',
-        'media',
-        'usage',
-        'valueShapes',
-        'formats',
-        'webpInput',
-        'autoConvert',
-        'files',
-        'maxSizeKB',
-        'durationMs',
-        'totalDurationMs',
-        'items',
-        'maxPromptLength',
-        'lastFrameOnly',
-      ])}`);
-    }
+  pushSectionCount(lines, 'resources', resources.length);
+  for (const [index, item] of resources.entries()) {
+    pushSectionRecordItem(lines, index, {
+      mode: item.mode,
+      media: item.mediaType,
+      usage: item.usage,
+      valueShapes: textValueShapes(item.valueShapes),
+      formats: textResourceFormats(item),
+      webpInput: textWebpInput(item),
+      autoConvert: textResourceAutoConvert(item),
+      files: textFileCount(item),
+      maxSizeKB: item.maxSizeKB,
+      durationMs: textDurationRange(item),
+      totalDurationMs: item.maxTotalDurationMs != null ? `<=${item.maxTotalDurationMs}` : undefined,
+      items: textItemCount(item),
+      maxPromptLength: item.maxPromptLength,
+      lastFrameOnly: item.supportLastFrameOnly,
+    }, [
+      'mode',
+      'media',
+      'usage',
+      'valueShapes',
+      'formats',
+      'webpInput',
+      'autoConvert',
+      'files',
+      'maxSizeKB',
+      'durationMs',
+      'totalDurationMs',
+      'items',
+      'maxPromptLength',
+      'lastFrameOnly',
+    ]);
   }
-  if (constraints.length) {
-    lines.push(`constraints.count=${constraints.length}`);
-    for (const [index, item] of constraints.entries()) {
-      lines.push(`constraint[${index}]: ${renderRecord(compactRecord({
-        target: item.target,
-        targetConfig: item.targetConfigCode && item.targetConfigCode !== item.target ? item.targetConfigCode : undefined,
-        allowedValues: textAllowValues(item.allowValues),
-        when: textConstraintConditions(item.conditions),
-        effect: item.effect,
-        priority: item.priority,
-        name: item.name,
-      }), ['target', 'targetConfig', 'allowedValues', 'when', 'effect', 'priority', 'name'])}`);
-    }
+  pushSectionCount(lines, 'constraints', constraints.length);
+  for (const [index, item] of constraints.entries()) {
+    pushSectionRecordItem(lines, index, {
+      target: item.target,
+      targetConfig: item.targetConfigCode && item.targetConfigCode !== item.target ? item.targetConfigCode : undefined,
+      allowedValues: textAllowValues(item.allowValues),
+      when: textConstraintConditions(item.conditions),
+      effect: item.effect,
+      priority: item.priority,
+      name: item.name,
+    }, ['target', 'targetConfig', 'allowedValues', 'when', 'effect', 'priority', 'name']);
+  }
+  if (data.modelGroupCode) {
+    lines.push('next:');
+    pushSectionKeyValue(lines, 'createSpec', `${commandPrefix()} model create-spec --model-group-code ${data.modelGroupCode}`);
+    pushSectionKeyValue(lines, 'reason', '读取创建命令写法、资源语法、fee/dry-run 前置步骤和示例');
   }
   return `${lines.join('\n')}\n`;
 }
@@ -1000,44 +1037,63 @@ function textKeyBinding(value) {
   return value;
 }
 
+function modelFeeNextCommand(data = {}) {
+  if (!data.feeCommand || !data.modelGroupCode) return null;
+  const args = [
+    `${commandPrefix()} ${data.feeCommand}`,
+    `--model-group-code ${data.modelGroupCode}`,
+    '--prompt "<prompt>"',
+  ];
+  if (data.taskKind === 'video') args.push('--duration <duration>', '--ratio <ratio>', '--quality <quality>');
+  if (data.taskKind === 'image') args.push('--ratio <ratio>', '--quality <quality>');
+  return args.join(' ');
+}
+
+function modelCreateExampleWithCode(example, modelGroupCode) {
+  if (!example || !modelGroupCode) return rewriteCommandPrefix(example);
+  return rewriteCommandPrefix(String(example).replaceAll('--model-group-code <code>', `--model-group-code ${modelGroupCode}`));
+}
+
 function formatModelCreateSpecOutput(data = {}) {
   const intents = Array.isArray(data.supportedIntents) ? data.supportedIntents : [];
   const examples = Array.isArray(data.examples) ? data.examples : [];
   const lines = ['ok model create-spec'];
-  lines.push(renderRecord(compactRecord({
+  pushSectionRecord(lines, 'summary', {
     modelGroupCode: data.modelGroupCode,
     taskKind: data.taskKind,
     create: data.createCommand,
     fee: data.feeCommand,
     statusTaskType: data.statusCommandTaskType,
-  }), ['modelGroupCode', 'taskKind', 'create', 'fee', 'statusTaskType']));
-  lines.push(renderRecord(compactRecord({
-    input: data.inputRequirement?.summary,
+  }, ['modelGroupCode', 'taskKind', 'create', 'fee', 'statusTaskType']);
+  pushSectionRecord(lines, 'input', {
+    summary: data.inputRequirement?.summary,
     acceptedModes: valueList(data.inputRequirement?.acceptedModes),
-  }), ['input', 'acceptedModes']));
-  lines.push(`intents.count=${intents.length}`);
+  }, ['summary', 'acceptedModes']);
+  pushSectionCount(lines, 'intents', intents.length);
   for (const [index, intent] of intents.entries()) {
-    lines.push(`intent[${index}]: ${renderRecord(compactRecord({
+    pushSectionRecordItem(lines, index, {
       mode: intent.mode,
       intent: intent.intent,
       args: valueList(intent.requiredArgs),
       usage: valueList(intent.resourceUsages),
       resources: valueList(intent.resourceSyntax),
       key: textKeyBinding(intent.promptBinding),
-    }), ['mode', 'intent', 'args', 'usage', 'resources', 'key'])}`);
-  }
-  if (examples.length) {
-    lines.push(`examples.count=${examples.length}`);
-    for (const [index, example] of examples.entries()) lines.push(`example[${index}]=${example}`);
+    }, ['mode', 'intent', 'args', 'usage', 'resources', 'key']);
   }
-  if (data.optionsCommand) lines.push(`options=${commandPrefix()} ${data.optionsCommand}`);
+  pushSectionCount(lines, 'examples', examples.length);
+  for (const [index, example] of examples.entries()) pushSectionItem(lines, index, rewriteCommandPrefix(example));
+  lines.push('next:');
+  if (data.optionsCommand) pushSectionKeyValue(lines, 'options', `${commandPrefix()} ${data.optionsCommand}`);
+  const feeNext = modelFeeNextCommand(data);
+  if (feeNext) pushSectionKeyValue(lines, 'fee', feeNext);
+  if (examples.length) pushSectionKeyValue(lines, 'dryRun', modelCreateExampleWithCode(examples[0], data.modelGroupCode));
   return `${lines.join('\n')}\n`;
 }
 
 function formatGuideTableRows(rows = []) {
   return (Array.isArray(rows) ? rows : []).map((item, index) => {
     const values = valueList(item.values);
-    return `field[${index}]: ${renderRecord(compactRecord({
+    return `  [${index}]: ${renderRecord(compactRecord({
       name: item.field,
       values,
       desc: item.description,
@@ -1047,20 +1103,20 @@ function formatGuideTableRows(rows = []) {
 
 function formatModelInputGuideOutput(data = {}) {
   const lines = ['ok model input-guide'];
-  lines.push('commonFields.count=' + (Array.isArray(data.commonFields) ? data.commonFields.length : 0));
+  pushSectionCount(lines, 'commonFields', Array.isArray(data.commonFields) ? data.commonFields.length : 0);
   lines.push(...formatGuideTableRows(data.commonFields));
-  lines.push('resourceFields.count=' + (Array.isArray(data.resourceFields) ? data.resourceFields.length : 0));
+  pushSectionCount(lines, 'resourceFields', Array.isArray(data.resourceFields) ? data.resourceFields.length : 0);
   lines.push(...formatGuideTableRows(data.resourceFields));
   const rules = Array.isArray(data.resourceRules) ? data.resourceRules : [];
-  if (rules.length) {
-    lines.push(`resourceRules.count=${rules.length}`);
-    for (const [index, rule] of rules.entries()) lines.push(`rule[${index}]=${rule}`);
-  }
+  pushSectionCount(lines, 'resourceRules', rules.length);
+  for (const [index, rule] of rules.entries()) pushSectionItem(lines, index, rule);
   const referenceKeyGuide = Array.isArray(data.referenceKeyGuide) ? data.referenceKeyGuide : [];
-  if (referenceKeyGuide.length) {
-    lines.push(`referenceKey.count=${referenceKeyGuide.length}`);
-    for (const [index, item] of referenceKeyGuide.entries()) lines.push(`referenceKey[${index}]=${item}`);
-  }
+  pushSectionCount(lines, 'referenceKey', referenceKeyGuide.length);
+  for (const [index, item] of referenceKeyGuide.entries()) pushSectionItem(lines, index, item);
+  lines.push('next:');
+  pushSectionKeyValue(lines, 'imageModels', `${commandPrefix()} model image-models --model <keyword>`);
+  pushSectionKeyValue(lines, 'videoModels', `${commandPrefix()} model video-models --model <keyword>`);
+  pushSectionKeyValue(lines, 'options', `${commandPrefix()} model options --model-group-code <modelGroupCode>`);
   return `${lines.join('\n')}\n`;
 }
 
@@ -1072,9 +1128,17 @@ function modelListNextCommand(commandName) {
   if (commandName === 'model image-models' || commandName === 'model video-models') {
     return `${commandPrefix()} model options --model-group-code <modelGroupCode>`;
   }
+  if (commandName === 'model asset-review-models') {
+    return `${commandPrefix()} create asset-groups --platform <platform> --name "<keyword>"`;
+  }
   return null;
 }
 
+function modelListAgentHint(commandName) {
+  if (commandName !== 'model image-models' && commandName !== 'model video-models') return null;
+  return '对每个候选运行 model options，并把候选模型、参数取值、默认值和资源能力展示给用户后再推荐或进入 fee/dry-run。';
+}
+
 function statusNextCommand(commandName, normalized) {
   if (!isPlainObject(normalized) || normalized.isTerminal !== false || !normalized.taskId) return null;
   const taskType = normalized.taskType || (commandName === 'task video-status' ? 'VIDEO_GROUP' : 'IMAGE_CREATE');
@@ -1206,6 +1270,8 @@ export function formatTextOutput(commandName, data, context = {}) {
   if (normalized.dryRun && !context.confirmCommand && context.executeCommand) lines.push(`next=${context.executeCommand}`);
   const modelNext = modelListNextCommand(commandName);
   if (modelNext) lines.push(`next=${modelNext}`);
+  const modelHint = modelListAgentHint(commandName);
+  if (modelHint) lines.push(`agentHint=${shortValue(modelHint)}`);
   const waitNext = statusNextCommand(commandName, normalized);
   if (waitNext) lines.push(`next=${waitNext}`);
   const subtitleNext = subtitleRemoveNextCommand(commandName, normalized);

package/packages/awb-core/src/standalone.js

@@ -24,6 +24,7 @@ const OPTION_SYNONYMS = {
   threads: ['concurrency'],
   output: ['format'],
   json: ['format'],
+  keyword: ['model'],
   input: ['inputFile'],
   in: ['inputFile'],
   dry: ['dryRun'],
@@ -60,6 +61,16 @@ function suggestSimilarOptions(unknownKey, allowedKeys) {
   for (const syn of synonyms) {
     if (allowedKeys.includes(syn)) record(syn, -1);
   }
+  if (unknownKey.length === 1) {
+    const ch = unknownKey.toLowerCase();
+    for (const allowed of allowedKeys) {
+      if (allowed.toLowerCase().startsWith(ch)) record(allowed, 1);
+    }
+    return [...scored.entries()]
+      .sort((x, y) => x[1] - y[1])
+      .slice(0, 3)
+      .map(([key]) => formatOptionName(key));
+  }
   for (const allowed of allowedKeys) {
     const a = unknownKey.toLowerCase();
     const b = allowed.toLowerCase();
@@ -153,6 +164,7 @@ function assignKwarg(kwargs, key, value) {
 function parseArgv(argv) {
   const commandParts = [];
   const kwargs = {};
+  const kwargRawFlags = {};
   let format = 'text';
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -182,10 +194,27 @@ function parseArgv(argv) {
       }
       continue;
     }
+    if (token.length > 1 && token.startsWith('-') && /^-[A-Za-z]/.test(token)) {
+      const raw = token.slice(1);
+      const eqIndex = raw.indexOf('=');
+      const keyPart = eqIndex >= 0 ? raw.slice(0, eqIndex) : raw;
+      const inlineValue = eqIndex >= 0 ? raw.slice(eqIndex + 1) : undefined;
+      const key = normalizeKey(keyPart);
+      if (!(key in kwargRawFlags)) kwargRawFlags[key] = token;
+      if (inlineValue !== undefined) {
+        assignKwarg(kwargs, key, inlineValue);
+      } else if (argv[index + 1] && !argv[index + 1].startsWith('-')) {
+        assignKwarg(kwargs, key, argv[index + 1]);
+        index += 1;
+      } else {
+        assignKwarg(kwargs, key, true);
+      }
+      continue;
+    }
     commandParts.push(token);
   }
 
-  return { commandName: commandParts.join(' '), kwargs, format };
+  return { commandName: commandParts.join(' '), kwargs, kwargRawFlags, format };
 }
 
 async function readVersion() {
@@ -812,6 +841,23 @@ function buildCommandWorkflow(command) {
   if (command.name === 'create asset') {
     next.push('读取 data.assetPath', '若后端返回审核 taskId，再运行 task wait --task-type ASSET_REGISTER');
   }
+  if (command.name === 'model image-models' || command.name === 'model video-models') {
+    next.push('读取 data.models[] 得到全部候选；用户给了模型口语名时保留同族全部候选，不只取第一个');
+    next.push('对每个候选运行 model options --model-group-code <modelGroupCode> 查看真实参数和素材约束');
+    next.push('先向用户展示候选模型 + 参数取值 + 资源能力，再推荐模型或进入 fee/dry-run');
+  }
+  if (command.name === 'model asset-review-models') {
+    next.push('读取 data.models[].platform', '用 create asset-groups --platform <platform> 查重或创建素材组');
+  }
+  if (command.name === 'model options') {
+    next.push('读取 params/resources/constraints 确认参数与素材约束', '运行 model create-spec --model-group-code <code> 查看创建写法和示例');
+  }
+  if (command.name === 'model create-spec') {
+    next.push('按 examples / supportedIntents 组装命令', '用户确认关键参数后先运行 create image-fee 或 create video-fee，再 dry-run');
+  }
+  if (command.name === 'model input-guide') {
+    next.push('运行 model image-models 或 model video-models 选择模型', '选定模型后运行 model options --model-group-code <code>');
+  }
   if (['create image-batch', 'create video-batch', 'create subject-batch'].includes(command.name)) {
     next.push('读取每项 status / taskId / error', '使用 task record-poll 或对应 wait 命令恢复批量结果');
   }
@@ -844,6 +890,7 @@ function buildAgentContract() {
       invalidation: '用户切换账号、团队、项目组、模型、素材、prompt 或关键参数后，只刷新受影响的缓存；不要重复跑未变化的 model options / create-spec / fee。',
     },
     workflowPolicy: [
+      '模型口语名命中后必须先展示候选模型、真实参数取值和资源能力；没有完成用户可见候选清单前，不得代选默认模型 / 参数，也不得进入 fee 或 dry-run。',
       '模型探索阶段只读 model list / options / create-spec；fee 只在用户确认关键参数后跑一次。',
       'supportsDryRun=true 的写入 / 扣费命令先 dry-run，确认后 yes；不要把 dry-run 当参数探索工具反复跑。',
       '用户给出多条同模型同参数任务时优先 batch + task-record-file，不要单条循环 create。',
@@ -886,6 +933,12 @@ function buildAgentContract() {
         },
       ],
     },
+    modelCandidatePresentation: {
+      purpose: '把 model image-models / video-models 与每个候选的 model options 转成用户可见清单，避免 Agent 内部看完 options 后直接代选。',
+      trigger: '用户问有哪些模型、给出口语名、或模型列表返回候选时都触发；即使只有一个候选也要展示真实可选项。',
+      requiredVisibleFields: ['displayName', 'modelDesc', 'taskQueueNum', 'quality values/default', 'ratio values/default', 'duration or generateNum values/default', 'resource modes/media/usages', 'channel or fast/pro differences'],
+      blockedBeforePresentation: ['create image-fee', 'create video-fee', 'create image --dry-run', 'create video --dry-run', 'default model recommendation', 'default quality/ratio/duration choice'],
+    },
     modelOptions: {
       command: `${commandPrefix()} model options --model-group-code <code>`,
       jsonCommand: `${commandPrefix()} model options --model-group-code <code> -f json`,
@@ -1182,28 +1235,37 @@ function printCommandHelp(command) {
   process.stdout.write(`${lines.join('\n')}\n`);
 }
 
-function validateCommandOptions(command, kwargs) {
+function validateCommandOptions(command, kwargs, kwargRawFlags = {}) {
   const allowedKeys = (command.args || []).map((arg) => normalizeKey(arg.name));
   const allowed = new Set(allowedKeys);
   const unknown = Object.keys(kwargs).filter((key) => !allowed.has(key));
   if (!unknown.length) return;
+  const displayFlag = (key) => kwargRawFlags[key] || formatOptionName(key);
   const suggestions = {};
   for (const unk of unknown) {
     const matches = suggestSimilarOptions(unk, allowedKeys);
-    if (matches.length) suggestions[formatOptionName(unk)] = matches;
+    if (matches.length) suggestions[displayFlag(unk)] = matches;
   }
+  const usedShortForm = unknown.some((key) => {
+    const flag = kwargRawFlags[key];
+    return flag && flag.startsWith('-') && !flag.startsWith('--');
+  });
   const baseHint = `运行 ${commandPrefix()} ${command.name} -h 查看可用参数。`;
+  const shortHint = usedShortForm
+    ? `本 CLI 仅支持 -f / -h / -v 等少数短选项，业务参数请使用 --xxx 长形式。`
+    : '';
   const suggestionParts = Object.entries(suggestions).map(([opt, matches]) => `${opt} → ${matches.join(' / ')}`);
-  const hint = suggestionParts.length
-    ? `你是不是想用：${suggestionParts.join('；')}？否则 ${baseHint}`
-    : baseHint;
-  throw new LingjingAwbCliError(`未知参数：${unknown.map(formatOptionName).join(', ')}`, {
+  const hintParts = [];
+  if (suggestionParts.length) hintParts.push(`你是不是想用：${suggestionParts.join('；')}？`);
+  if (shortHint) hintParts.push(shortHint);
+  hintParts.push(baseHint);
+  throw new LingjingAwbCliError(`未知参数：${unknown.map(displayFlag).join(', ')}`, {
     type: 'unknown_option',
     exitCode: 2,
-    hint,
+    hint: hintParts.join(' '),
     details: {
       command: command.name,
-      unknownOptions: unknown.map(formatOptionName),
+      unknownOptions: unknown.map(displayFlag),
       ...(Object.keys(suggestions).length ? { suggestions } : {}),
     },
   });
@@ -1265,7 +1327,7 @@ export async function runStandaloneCli(argv = process.argv.slice(2)) {
     return;
   }
 
-  const { commandName: rawCommandName, kwargs, format } = parseArgv(argv);
+  const { commandName: rawCommandName, kwargs, kwargRawFlags, format } = parseArgv(argv);
   const commandName = resolveCommandName(rawCommandName, commands);
   const command = commands.find((item) => item.name === commandName);
   if (!command) {
@@ -1289,7 +1351,7 @@ export async function runStandaloneCli(argv = process.argv.slice(2)) {
 
   const startedAt = Date.now();
   try {
-    validateCommandOptions(command, kwargs);
+    validateCommandOptions(command, kwargs, kwargRawFlags);
     const data = command.virtual === 'schema'
       ? buildCommandSchema(commands, kwargs, version)
       : await command.func({ command }, kwargs);

package/skills/lj-awb/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lj-awb
-version: 0.3.17
+version: 0.3.18
 description: "灵境 AWB CLI skill。使用 `lj-awb` 命令调用动漫平台 / AWB 云端能力，覆盖认证、项目组、积分、模型发现、上传、统一 create 创建域、任务查询、最终产物 artifact CRUD 与本地 JSON 导入。用户说生图、生视频、主体、音色、素材加白、去字幕、artifact 写入或查询时使用。正式生成、切换项目组、清空认证、artifact 写入等写入或扣费动作前必须确认。"
 metadata:
   requires:
@@ -43,6 +43,8 @@ LINGJING_AWB_CMD="$(bash "$(dirname "$0")/scripts/resolve-lj-awb-cmd.sh")"
 lj-awb schema -f json
 ```
 
+如果只是不确定某个命令参数，优先读精确契约，例如 `lj-awb schema --domain model --command video-models -f json`。schema 查询必须先返回，再组织业务命令；不要把 schema 查询和猜测命令放进同一批并行调用。
+
 如果用户已经给出完整只读命令，且该命令在本 skill 已知范围内，可以直接执行，不必为了形式补跑 schema。命令名、参数名、requiredOptions、safety、workflow.nextActions 都以 schema 为准。旧根域 `image` / `video` / `asset` / `subject` 不存在，不要尝试旧入口。
 
 ## 能力地图
@@ -84,7 +86,8 @@ lj-awb schema -f json
 - `fee` 是最终估价，不是参数探索工具。不要为多个 quality / duration / ratio / 渠道组合反复跑 fee。
 - 正式图片 / 视频任务要带 `--project-group-no`，除非命令 schema 没有该参数。
 - 命令返回 `nextCommand`、`nextRefSubject`、`nextVoiceArg` 时优先复用返回值，不手拼。
-- compact text 是默认输出；只有 schema、options、create-spec、完整嵌套结构或脚本解析时用 `-f json`。
+- compact text 是默认输出；复杂模型命令按 `section:` + 缩进 `key=value` 输出，先按分区读 `summary` / `params` / `resources` / `constraints` / `intents` / `examples` / `next`。只有 schema、options、create-spec、完整嵌套结构或脚本解析时用 `-f json`。
+- 模型口语名命中后必须过“候选展示门”：先把候选模型、真实参数取值和资源能力转成用户可见清单，再推荐或追问；不能只在内部读完 `model options` 就直接代选默认模型 / 参数。
 - 积分口径只把 `billingPointBalance` 当可扣积分余额；`projectBudgetBalance` 是项目组预算，不要混说。
 - 不直连 material / asset / 外部服务；所有业务能力统一通过 `lj-awb`。
 

package/skills/lj-awb/VERSION

@@ -1 +1 @@
-0.3.17
+0.3.18

package/skills/lj-awb/compat.json

@@ -1,6 +1,6 @@
 {
-  "skillVersion": "0.3.17",
-  "minCliVersion": "0.3.17",
+  "skillVersion": "0.3.18",
+  "minCliVersion": "0.3.18",
   "preferredCommand": "lj-awb",
   "updatedAt": "2026-05-19"
 }

package/skills/lj-awb/modules/auth.md

@@ -18,7 +18,7 @@
 
 ## 规则
 
-- 自动化环境优先使用 `LINGJING_AWB_ACCESS_KEY`，兼容 `AWB_ACCESS_KEY` / `AWB_CODE` / `ANIME_ACCESS_KEY`。
+- 自动化环境只使用 `LINGJING_AWB_ACCESS_KEY`。
 - 不要把 access key 明文写入对话、日志、文档或任务台账。
 - `auth status` 只读本地配置；正式创作前用 `auth verify`、`account info` 或 `doctor --verify` 确认远端可用。
 - `auth clear` 是本地破坏性动作，必须先确认或 dry-run。

package/skills/lj-awb/modules/create-contract.md

@@ -105,7 +105,7 @@ Agent 必须按顺序做：
 
 1. 本轮尚未验证时运行 `doctor --verify`，确认认证、API、项目组和 UTF-8 环境。
 2. 没有可复用候选时运行 `model image-models` 或 `model video-models`，按用户目的筛候选模型。
-3. 向用户展示候选时**不是只列名字**，按三步走：
+3. 向用户展示候选是硬门槛，**不是只列名字，也不是内部摘要**；没有完成这一步，不得推荐默认模型 / 参数，不得进入 `fee` 或 `create --dry-run`。按三步走：
    - **基本信息**：`displayName` + `modelDesc`（运营填的特性描述，没填就只报 displayName）+ `taskQueueNum` 的人话表达（0 = 队列空闲 / 1-10 = 排队中 / >10 = 等待较长）。
    - **参数取值**：对每个候选**并行**跑 `lj-awb model options --model-group-code <code> -f json`，把可控参数实际取值列出来：quality 档位列表 / ratio 比例列表 / video 的 duration 范围 / image 的 generateNum 上限 / 支持的资源模式（reference · first_frame · last_frame · audio · subject） / 是否暴露 needAudio / feeCalcType 转人话。
    - **追问参数**：用户看完真实选项后再追问 quality / ratio / duration / generateNum。**不要在用户看过 `model options` 输出前就给出 16:9 / 720P 这类自编选项**——必须是模型真实支持的值。

package/skills/lj-awb/modules/driver.md

@@ -5,6 +5,7 @@
 ## 核心原则
 
 - CLI schema 是命令事实来源：非单条查询任务、命令不确定或涉及写入 / 扣费时，本轮只读一次 `lj-awb schema -f json`，命令名、参数名、安全规则和 nextActions 都以 schema 为准。
+- 命令或参数不确定时，schema 查询是阻塞前置步骤：先运行精确 schema（例如 `lj-awb schema --domain model --command video-models -f json`）并等结果返回，再根据 `options[].flag` 组织业务命令；不要把 schema 查询和猜测命令放在同一批并行工具调用里。
 - Skill 是驱动器，不是命令百科。先在本模块决定链路，只在需要时加载一个细节模块。
 - 同一对话维护 AWB 状态账本；除非用户切换账号、团队、项目组、模型、素材、prompt 或关键参数，否则不要重复跑同样的查询。
 - 写入 / 扣费命令遵循 schema safety：`supportsDryRun=true` 先 dry-run，`requiresConfirmation=true` 经用户确认后再 `--yes`。
@@ -51,13 +52,23 @@ CLI 当前能力分为：
 1. 若本轮未验证远端认证和项目组，运行 `doctor --verify`，必要时 `project current`。
 2. 根据用户目标选任务类型：生图查 `model image-models`，生视频查 `model video-models`。
 3. 如果同一关键词已有候选，不重复查列表；只在用户换模型关键词时刷新。
-4. 对候选跑 `model options`，展示真实参数和资源能力；用户选定模型后补 `model create-spec`。
+4. 对候选跑 `model options`，通过“模型候选展示门”把真实参数和资源能力展示给用户；用户选定模型后补 `model create-spec`。
 5. 按 [`task-manual.md`](task-manual.md) 选择资源模式，按 [`create-contract.md`](create-contract.md) 校验素材、占位符、`needAudio` 和模式互斥。
 6. 只追问会影响价格 / 效果且用户未给出的关键参数；用户说“默认”才使用 defaultValue。
 7. 参数确认后跑一次 `create image-fee` 或 `create video-fee`，不要用 fee 做多组合探索。
 8. 跑一次 `create image/video --dry-run` 展示最终 prompt、资源、参数、积分。
 9. 用户确认后 `--yes`。返回 `nextCommand` 时直接执行它等待结果。
 
+### 模型候选展示门
+
+只要用户给了模型口语名（如 `sd2`、`gpt`、`banana`、`可灵`）或模型查询返回候选，Agent 必须先完成这个门槛，才能推荐默认模型 / 默认参数、进入 `fee` 或 `create --dry-run`。
+
+1. 用 schema 或命令帮助确认过滤参数名，模型关键词统一走 `--model <keyword>`，不要猜 `--keyword`。
+2. 跑 `model image-models --model <keyword> -f json` 或 `model video-models --model <keyword> -f json`。用户已经给出口语名时，同族候选全部保留；不要只取第一个。
+3. 对每个候选并行跑 `model options --model-group-code <code> -f json`，读取真实 `quality`、`ratio`、`duration` / `generateNum`、默认值、资源模式和约束。
+4. 必须向用户输出可见清单：模型显示名、描述、排队状态、可选参数、默认值、支持的资源模式（图片 / 视频 / 音频 reference、首帧 / 首尾帧、主体等）、渠道差异。`modelGroupCode` 默认只内部使用，除非用户主动问技术 ID。
+5. 用户看完清单后再问关键参数或给建议。即使只命中 1 个候选，也要展示该模型的真实可选项；不要用“我倾向 4:3 / 5s / 720P”代替候选清单。
+
 ### 批量任务
 
 - 用户给出 2 条以上同模型同参数任务时，优先建议 `create image-batch` / `create video-batch`。

package/skills/lj-awb/modules/model.md

@@ -22,7 +22,16 @@ lj-awb model image-models --model "<keyword>"
 lj-awb model video-models --model "<keyword>"
 ```
 
-候选展示走 [`driver.md`](driver.md) 的创作链条：基本信息 → 并行跑 `model options` 列真实参数取值 → 看完真实选项后追问。不要把原始 JSON 整段粘给用户。模型列表里 `inputModes` / `params` 摘要只用于**初筛**；最终枚举值和限制以 `model options` 为准。`modelGroupCode` 是技术 ID，agent 内部跑命令用，**默认不展示给用户**。
+候选展示走 [`driver.md`](driver.md) 的“模型候选展示门”：基本信息 → 并行跑 `model options` 列真实参数取值和资源能力 → 看完真实选项后追问。不要把原始 JSON 整段粘给用户，但必须把候选转成用户可读清单；不能只在内部读完 options 后直接代选模型或参数。
+
+用户可见清单至少包含：
+
+- 模型显示名、模型描述和排队状态。
+- `quality`、`ratio`、视频 `duration` 或图片 `generateNum` 的可选值与默认值。
+- 资源能力：reference 支持哪些媒体，是否支持音频参考、视频参考、首帧 / 首尾帧、主体引用。
+- 同底模不同渠道 / Fast / Pro 等差异；如果参数完全一致，可以说明主要按队列、渠道或用户偏好选择。
+
+模型列表里 `inputModes` / `params` 摘要只用于**初筛**；最终枚举值和限制以 `model options` 为准。`modelGroupCode` 是技术 ID，agent 内部跑命令用，**默认不展示给用户**。
 
 ## 获取参数约束
 

package/skills/lj-awb/modules/task-manual.md

@@ -5,8 +5,8 @@
 ## 创作前固定流程
 
 1. 本轮尚未验证时运行 `lj-awb doctor --verify`，确认认证、API、项目组、UTF-8。
-2. 没有可复用候选时运行 `model image-models` 或 `model video-models`，按用户目标筛 2-4 个候选。
-3. 选中模型的 `model options` 未缓存时运行 `model options --model-group-code <code> -f json`，读取参数取值和素材约束。
+2. 没有可复用候选时运行 `model image-models` 或 `model video-models`，按用户目标筛候选；用户给了口语名时保留同族全部候选，不只取第一项。
+3. 进入“模型候选展示门”：对候选跑 `model options --model-group-code <code> -f json`，把每个候选的参数取值、默认值、素材约束和资源模式转成用户可见清单。
 4. 选中模型的创建规格未缓存时运行 `model create-spec --model-group-code <code> -f json`。
 5. 用 `inputRequirement` 判断是否必须有视觉输入；用 `supportedIntents` 判断素材模式；用 `model options.params` 判断 `ratio`、`quality`、`duration` 等枚举。
 6. 在 `fee` 或 `create --dry-run` 前，先确认用户未提供但会影响价格 / 效果的关键参数：视频 `quality`、`duration`、约束后仍可选的 `ratio`，以及用户明确要输出音效时的 `needAudio`；图片 `quality`、`ratio`、`generateNum`。
@@ -17,6 +17,7 @@
 ## 确认选项和验证拆开
 
 - `model options` / `model create-spec` 是只读验证，可以先跑，用来收集候选值、默认值、素材模式和约束。
+- `model options` 结果必须先转成用户可见候选清单；不能只在内部看完后直接说“我建议 4:3、720P、5s”。
 - `fee` 会基于已选参数估价，`create --dry-run` 会基于已选参数组装请求；如果用户还没给 `quality`、`duration`、可选 `ratio`、`generateNum` 这类关键参数，先问用户，不要先用默认值跑一遍。
 - 追问时给出候选值和默认值，例如：“还差会影响价格 / 效果的参数：画质 720 / 1080（默认 720），时长 3-15 秒（默认 5）。你希望用哪组？”
 - 用户回复“按默认”后，才可以使用 `model options.params[].defaultValue` 继续估价和 dry-run。

package/skills/lj-awb/references/error-codes.md

@@ -18,7 +18,7 @@ CLI 失败时 envelope 形如：
 | `1` | `subject_voice_failed` | 主体音色创建任务已失败 | 看 `details.errorMessage`，调整音频 / 视频来源后重新创建 |
 | `2` | `argument_error` | 必填参数缺失、参数格式 / 枚举不合法 | 按 `hint` 补参数；用 `lj-awb schema --command <name> -f json` 查 `requiredOptions / requiredAnyOptions` |
 | `2` | `unknown_command` / `unknown_option` | 命令名 / 参数名打错 | 跑 `lj-awb -h` 或对应子域 `lj-awb <domain> -h` 重查命令 |
-| `3` | `auth_required` | 缺少 access key | 提示用户 `lj-awb auth login --access-key <key> --yes` 或设置 `LINGJING_AWB_ACCESS_KEY` |
+| `3` | `auth_required` | 缺少 access key | 提示用户 `lj-awb auth login --access-key <key>` 或设置 `LINGJING_AWB_ACCESS_KEY` |
 | `3` | `auth_failed` | access key 无效 / 已过期（HTTP 401） | 跑 `auth verify` 确认；提示重新登录 |
 | `10` | `confirmation_required` | 写入 / 扣费 / 切换上下文动作未确认 | 向用户复述 `details.action` 后追加 `--yes` 重跑 |
 | `20` | `task_still_running` | 等待窗口结束但任务未终态 | 直接续跑 `task wait --task-id ... --wait-seconds <n>`，**不代表失败** |

package/skills/lj-awb/references/model-options-read.md

@@ -4,6 +4,7 @@
 
 ## 默认 Text 怎么读
 
+- 默认 text 是“分区 key=value”：先看 `summary:`，再看 `params:`、`resources:`、`constraints:`，最后看 `next:`。每个分区的 `count` 表示列表数量，列表项使用 `[0]: key=value ...`。
 - `params[]`：模型暴露的可控参数和约束；这里只给参数 key，不给 create 命令 flag。
 - `values`：枚举取值，只能从这里选。
 - `default`：模型默认值；用户没明确指定时通常不必显式传，但清晰度、比例、时长这类关键项仍要确认。
@@ -30,12 +31,13 @@ JSON 里会保留更完整的参数 / 资源 / 条件约束字段，但仍不承
 ## 使用顺序
 
 1. `model image-models` / `model video-models` 按关键词找候选。
-2. `model options --model-group-code <code>` 读取可传参数和素材约束。
-3. `model create-spec --model-group-code <code>` 读取输入模式、素材绑定规则和示例命令。
-4. 如果用户缺少关键价格 / 效果参数，先展示候选值和默认值，请用户选择或确认“按默认”。
-5. `fee` 估价。
-6. `create --dry-run` 预览请求。
-7. 用户确认后 `create --yes`。
+2. 对候选逐个运行 `model options --model-group-code <code>`，读取可传参数和素材约束。
+3. 把候选模型、参数取值、默认值、资源能力转成用户可见清单；这是进入推荐 / 追问 / fee 前的硬门槛。
+4. `model create-spec --model-group-code <code>` 读取输入模式、素材绑定规则和示例命令。
+5. 如果用户缺少关键价格 / 效果参数，先展示候选值和默认值，请用户选择或确认“按默认”。
+6. `fee` 估价。
+7. `create --dry-run` 预览请求。
+8. 用户确认后 `create --yes`。
 
 ## 判断口径