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

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

@@ -1,3 +1,8 @@
+import { Chalk } from 'chalk';
+import Table from 'cli-table3';
+
+const CHALK = new Chalk({ level: 1 });
+
 function isPlainObject(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -659,6 +664,21 @@ function shortValue(value) {
   return text.length > 120 ? `${text.slice(0, 117)}...` : text;
 }
 
+function formatPercent(value) {
+  if (value === undefined || value === null || value === '') return '';
+  const number = Number(value);
+  if (!Number.isFinite(number)) return '';
+  const percent = number > 1 ? number : number * 100;
+  const rounded = Math.round(percent * 10) / 10;
+  const text = Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+  return `${text}%`;
+}
+
+function shortRecordValue(key, value) {
+  if (key === 'successRate') return formatPercent(value) || shortValue(value);
+  return shortValue(value);
+}
+
 function valueList(values, limit = 12) {
   if (!Array.isArray(values) || !values.length) return undefined;
   const items = values
@@ -678,7 +698,43 @@ function renderRecord(record, preferredKeys = [], excludedKeys = []) {
     ...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])),
   ];
-  return keys.map((key) => `${key}=${shortValue(record[key])}`).join(' ');
+  return keys.map((key) => `${key}=${shortRecordValue(key, 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}=${shortRecordValue(key, 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) {
@@ -704,6 +760,7 @@ function rowSummary(row) {
     'modelDesc',
     'modelStatus',
     'taskQueueNum',
+    'successRate',
     'feeCalcType',
     'inputModes',
     'params',
@@ -835,7 +892,7 @@ function rowSummary(row) {
       if (Array.isArray(value) && value.length === 0) return false;
       return true;
     })
-    .map((key) => `${key}=${shortValue(row[key])}`)
+    .map((key) => `${key}=${shortRecordValue(key, row[key])}`)
     .join(' ');
 }
 
@@ -872,8 +929,30 @@ function textItemCount(item = {}) {
   return undefined;
 }
 
+function textCountRange(item = {}) {
+  if (item.minCount != null && item.maxCount != null && item.minCount === item.maxCount) return String(item.maxCount);
+  if (item.minCount != null && item.maxCount != null) return `${item.minCount}..${item.maxCount}`;
+  if (item.minCount != null) return `>=${item.minCount}`;
+  if (item.maxCount != null) return `<=${item.maxCount}`;
+  return item.value;
+}
+
+function textLimitSummary(item = {}) {
+  if (!isPlainObject(item)) return undefined;
+  const parts = [];
+  const files = textFileCount(item);
+  const duration = textDurationRange(item);
+  const items = textItemCount(item);
+  if (files) parts.push(`files${files}`);
+  if (duration) parts.push(`durationMs${duration}`);
+  if (item.maxTotalDurationMs != null) parts.push(`totalDurationMs<=${item.maxTotalDurationMs}`);
+  if (item.maxSizeKB != null) parts.push(`maxSizeKB<=${item.maxSizeKB}`);
+  if (items) parts.push(`items${items}`);
+  return parts.length ? parts.join('|') : undefined;
+}
+
 function textAllowValues(values = []) {
-  return Array.isArray(values) && values.length ? valueList(values) : '<none>';
+  return Array.isArray(values) && values.length ? valueList(values) : undefined;
 }
 
 function textConditionValue(value) {
@@ -887,6 +966,7 @@ function textConstraintConditions(conditions = []) {
   return conditions
     .map((item) => {
       const key = item.key || item.configCode;
+      if (item.meaning === 'count') return key ? `${key}=${textCountRange(item)}` : null;
       return key ? `${key}=${textConditionValue(item.value)}` : null;
     })
     .filter(Boolean)
@@ -925,70 +1005,72 @@ 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,
+      limits: textLimitSummary(item.limits),
+      priority: item.priority,
+      name: item.name,
+    }, ['target', 'targetConfig', 'allowedValues', 'when', 'effect', 'limits', '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 +1082,136 @@ function textKeyBinding(value) {
   return value;
 }
 
+function localizedIntentMode(value, taskKind = '') {
+  const mode = String(value || '');
+  const labels = {
+    prompt_only: taskKind === 'video' ? '文本生成视频' : '文本生成图片',
+    reference: taskKind === 'video' ? '参考素材生成' : '参考图生成',
+    frames: '首帧/尾帧生成',
+    storyboard: '关键帧/故事板生成',
+    keyframe: '关键帧生成',
+  };
+  return labels[mode] || localizedInputMode(mode, taskKind);
+}
+
+function localizedIntentText(value, mode, taskKind = '') {
+  const text = String(value || '');
+  if (!text) return localizedIntentMode(mode, taskKind);
+  const normalized = text.trim();
+  if (normalized === '参考模式') return taskKind === 'video' ? '参考素材生成' : '参考图生成';
+  if (normalized === 'frames 模式') return '首帧/尾帧生成';
+  if (normalized === 'prompt_only 模式') return localizedIntentMode('prompt_only', taskKind);
+  if (normalized === '多帧 / 故事板模式') return '关键帧/故事板生成';
+  return normalized
+    .replaceAll('frames', '首帧/尾帧')
+    .replaceAll('first_frame', '首帧')
+    .replaceAll('last_frame', '尾帧')
+    .replaceAll('reference', '参考素材')
+    .replaceAll('prompt_only', '纯文本');
+}
+
+function localizedPromptBinding(value) {
+  const labels = {
+    key_required: '必须绑定 key',
+    required: '必须绑定 key',
+    optional_key: '可选 key',
+    optional: '可选 key',
+    none: '不需要',
+  };
+  return labels[value] || prettyValue(value);
+}
+
+function localizedModeList(values = [], taskKind = '') {
+  if (!Array.isArray(values) || !values.length) return '';
+  return values.map((item) => localizedIntentMode(item, taskKind)).join('、');
+}
+
+function localizedCreateSpecSummary(value) {
+  return String(value || '')
+    .replaceAll('prompt_only', '纯文本')
+    .replaceAll('reference', '参考素材')
+    .replaceAll('frames', '首帧/尾帧')
+    .replaceAll('storyboard', '关键帧/故事板');
+}
+
+function localizedGuideValues(row = {}) {
+  const values = Array.isArray(row.values) ? row.values : [];
+  if (!values.length) return '';
+  if (row.field === 'resources[].usage') {
+    return values.map((value) => `${value}（${localizedUsage(value)}）`).join('、');
+  }
+  if (row.field === 'resources[].type') {
+    return values.map((value) => `${value}（${localizedMedia(value)}）`).join('、');
+  }
+  if (row.field === 'resources[].source.kind') {
+    const labels = { url: '文件/URL/平台素材路径', asset_id: '资产 ID' };
+    return values.map((value) => `${value}（${labels[value] || value}）`).join('、');
+  }
+  return joinValueList(values, 8);
+}
+
+function commandArgLines(values = []) {
+  if (!Array.isArray(values) || !values.length) return '';
+  return values.map((value) => prettyValue(value)).join('\n');
+}
+
+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 +1221,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 +1246,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');
@@ -1090,6 +1272,1753 @@ function subtitleRemoveNextCommand(commandName, normalized) {
   return `${commandPrefix()} create video-subtitle-removal --source-task-id ${normalized.taskId}${projectGroupPart} --dry-run`;
 }
 
+const OUTPUT_KIND_BY_COMMAND = {
+  doctor: 'environment_report',
+  schema: 'command_schema',
+  'auth status': 'auth_status',
+  'auth verify': 'auth_status',
+  'auth login': 'auth_result',
+  'auth clear': 'generic',
+  'account info': 'account_summary',
+  'account teams': 'team_list',
+  'account switch-team': 'generic',
+  'project list': 'project_list',
+  'project current': 'project_summary',
+  'project use': 'generic',
+  'project users': 'project_user_list',
+  'project create': 'generic',
+  'project update': 'generic',
+  'project ensure': 'generic',
+  'credits balance': 'credits_balance',
+  'credits usage': 'credits_usage',
+  'model image-models': 'model_list',
+  'model video-models': 'model_list',
+  'model asset-review-models': 'asset_review_model_list',
+  'model options': 'model_options',
+  'model create-spec': 'model_create_spec',
+  'model input-guide': 'model_input_guide',
+  'upload files': 'upload_result',
+  'create image-fee': 'fee_estimate',
+  'create image': 'task_submission',
+  'create image-batch': 'batch_task_submission',
+  'task image-status': 'task_status',
+  'create video-fee': 'fee_estimate',
+  'create video': 'task_submission',
+  'create video-batch': 'batch_task_submission',
+  'task video-status': 'task_status',
+  'create video-subtitle-removal': 'subtitle_task_submission',
+  'task video-subtitle-status': 'subtitle_task_status',
+  'task list': 'task_list',
+  'task wait': 'task_status',
+  'task records': 'local_task_records',
+  'task record-poll': 'batch_task_status',
+  'create asset-match-actor': 'asset_match_list',
+  'create asset-groups': 'asset_group_list',
+  'create asset-group-get': 'asset_group_detail',
+  'create asset-group': 'asset_group_write_result',
+  'create asset-group-update': 'asset_group_write_result',
+  'create asset': 'asset_register_result',
+  'artifact script get': 'artifact_full',
+  'artifact script document': 'artifact_record',
+  'artifact script rows': 'artifact_list',
+  'artifact script row': 'artifact_record',
+  'artifact script children': 'artifact_list',
+  'artifact script upsert-row': 'artifact_write_result',
+  'artifact script delete-row': 'artifact_delete_result',
+  'artifact script import': 'artifact_import_result',
+  'artifact asset get': 'artifact_full',
+  'artifact asset actors': 'artifact_list',
+  'artifact asset actor': 'artifact_record',
+  'artifact asset props': 'artifact_list',
+  'artifact asset prop': 'artifact_record',
+  'artifact asset locations': 'artifact_list',
+  'artifact asset location': 'artifact_record',
+  'artifact asset upsert-actor': 'artifact_write_result',
+  'artifact asset upsert-prop': 'artifact_write_result',
+  'artifact asset upsert-location': 'artifact_write_result',
+  'artifact asset upsert-actor-state': 'artifact_write_result',
+  'artifact asset upsert-prop-state': 'artifact_write_result',
+  'artifact asset upsert-location-state': 'artifact_write_result',
+  'artifact asset delete-actor': 'artifact_delete_result',
+  'artifact asset delete-prop': 'artifact_delete_result',
+  'artifact asset delete-location': 'artifact_delete_result',
+  'artifact asset delete-actor-state': 'artifact_delete_result',
+  'artifact asset delete-prop-state': 'artifact_delete_result',
+  'artifact asset delete-location-state': 'artifact_delete_result',
+  'artifact asset import': 'artifact_import_result',
+  'artifact video get': 'artifact_full',
+  'artifact video episodes': 'artifact_list',
+  'artifact video episode': 'artifact_record',
+  'artifact video scenes': 'artifact_list',
+  'artifact video scene': 'artifact_record',
+  'artifact video clips': 'artifact_list',
+  'artifact video clip': 'artifact_record',
+  'artifact video upsert-episode': 'artifact_write_result',
+  'artifact video upsert-scene': 'artifact_write_result',
+  'artifact video upsert-clip': 'artifact_write_result',
+  'artifact video update-clip-urls': 'artifact_write_result',
+  'artifact video delete-episode': 'artifact_delete_result',
+  'artifact video delete-scene': 'artifact_delete_result',
+  'artifact video delete-clip': 'artifact_delete_result',
+  'artifact video import-storyboard': 'artifact_import_result',
+  'artifact clip get': 'artifact_full',
+  'artifact clip episodes': 'artifact_list',
+  'artifact clip episode': 'artifact_record',
+  'artifact clip episode-by-id': 'artifact_record',
+  'artifact clip upsert-episode': 'artifact_write_result',
+  'artifact clip upsert-batch': 'artifact_import_result',
+  'artifact clip update-status': 'artifact_status_update',
+  'artifact clip delete-episode': 'artifact_delete_result',
+  'create subject-list': 'subject_list',
+  'create subject': 'subject_publish_result',
+  'create subject-wait': 'subject_status',
+  'create subject-voice-list': 'subject_voice_list',
+  'create subject-voice': 'subject_voice_create_result',
+  'create subject-voice-wait': 'subject_voice_status',
+  'create subject-batch': 'batch_subject_publish_result',
+};
+
+const KIND_TITLES = {
+  account_summary: '账号概览',
+  artifact_delete_result: '最终产物删除结果',
+  artifact_full: '最终产物详情',
+  artifact_import_result: '最终产物导入结果',
+  artifact_list: '最终产物列表',
+  artifact_record: '最终产物记录',
+  artifact_status_update: '剪辑状态更新结果',
+  artifact_write_result: '最终产物写入结果',
+  asset_group_detail: '素材组详情',
+  asset_group_list: '素材组列表',
+  asset_group_write_result: '素材组写入结果',
+  asset_match_list: '素材匹配结果',
+  asset_review_model_list: '素材审核模型',
+  asset_register_result: '素材注册结果',
+  auth_result: '认证结果',
+  auth_status: '认证状态',
+  batch_subject_publish_result: '批量主体提交结果',
+  batch_task_status: '批量任务状态',
+  batch_task_submission: '批量任务提交结果',
+  command_schema: '命令 Schema',
+  credits_balance: '积分余额',
+  credits_usage: '积分用量',
+  environment_report: '环境体检',
+  fee_estimate: '费用预估',
+  generic: '命令结果',
+  local_task_records: '本地任务台账',
+  model_create_spec: '模型创建写法',
+  model_input_guide: '模型输入指南',
+  model_list: '模型列表',
+  model_options: '模型参数与素材约束',
+  project_list: '项目组列表',
+  project_summary: '项目组摘要',
+  project_user_list: '项目组成员',
+  subject_list: '主体列表',
+  subject_publish_result: '主体创建结果',
+  subject_status: '主体状态',
+  subject_voice_create_result: '主体音色创建结果',
+  subject_voice_list: '主体音色列表',
+  subject_voice_status: '主体音色状态',
+  subtitle_task_status: '去字幕任务状态',
+  subtitle_task_submission: '去字幕任务提交结果',
+  task_list: '任务列表',
+  task_status: '任务状态',
+  task_submission: '任务提交结果',
+  team_list: '团队列表',
+  upload_result: '上传结果',
+};
+
+const COMMAND_TITLES = {
+  doctor: '环境体检',
+  schema: '命令 Schema',
+  'auth clear': '清空认证结果',
+  'account switch-team': '团队切换结果',
+  'project use': '项目组切换结果',
+  'project create': '项目组创建结果',
+  'project update': '项目组更新结果',
+  'project ensure': '项目组确保结果',
+  'create image': '生图任务提交结果',
+  'create video': '生视频任务提交结果',
+  'create image-batch': '批量生图提交结果',
+  'create video-batch': '批量生视频提交结果',
+  'create video-subtitle-removal': '去字幕任务提交结果',
+  'create subject': '主体创建结果',
+  'create subject-wait': '主体状态',
+  'create subject-voice': '主体音色创建结果',
+  'create subject-voice-wait': '主体音色状态',
+};
+
+const FIELD_LABELS = {
+  acceptedModes: '可用输入模式',
+  accessKey: 'Access Key',
+  action: '动作',
+  actorCount: '角色数',
+  actorKey: '角色 Key',
+  arch: '架构',
+  assetCount: '素材数',
+  assetId: '素材 ID',
+  assetKey: '素材 Key',
+  assetKind: '素材类型',
+  assetName: '素材名',
+  assetPath: '素材路径',
+  authType: '认证方式',
+  backendPath: '后端路径',
+  batchCount: '批次数',
+  billingPointBalance: '可扣积分余额',
+  billingPointRemainingAfter: '扣除后可扣积分',
+  checkedAt: '检查时间',
+  cleared: '已清空',
+  clipCount: 'Clip 数',
+  clipId: 'Clip ID',
+  command: '命令',
+  configured: '已配置',
+  count: '数量',
+  created: '已创建',
+  createCommand: '创建命令',
+  customBizId: '业务追踪 ID',
+  deleted: '已删除',
+  description: '描述',
+  displayName: '展示名',
+  taskKind: '任务类型',
+  doctorStatus: '体检状态',
+  dryRun: '预览模式',
+  duration: '时长',
+  elementId: '主体元素 ID',
+  enabled: '启用',
+  entityKey: '实体 Key',
+  episodeCount: '集数',
+  episodeId: '集 ID',
+  errorMessage: '错误信息',
+  externalId: '外部 ID',
+  fileCount: '文件数',
+  feeCommand: '估价命令',
+  format: '格式',
+  generateNum: '生成数量',
+  gmtCreate: '创建时间',
+  groupId: '团队 ID',
+  groupName: '团队名称',
+  id: 'ID',
+  imported: '已导入',
+  inputDir: '输入目录',
+  inputFile: '输入文件',
+  inputSummary: '输入摘要',
+  isSelected: '当前选中',
+  isTerminal: '终态',
+  key: 'Key',
+  localFileCount: '本地文件数',
+  locationCount: '场景数',
+  locationKey: '场景 Key',
+  memberCount: '成员数',
+  messageCount: '消息数',
+  modelCode: '模型编码',
+  modelDesc: '模型说明',
+  modelGroupCode: '模型组编码',
+  modelStatus: '模型状态',
+  name: '名称',
+  needAudio: '需要音频',
+  nextCommand: '下一步命令',
+  nextRefSubject: '主体引用参数',
+  nextVoiceArg: '音色参数',
+  originUrls: '原始素材',
+  parentKey: '父级 Key',
+  platform: '平台',
+  point: '预算点数',
+  pointCost: '预计消耗积分',
+  pointNo: '积分规格',
+  pointTotal: '积分合计',
+  projectBudgetBalance: '项目预算余额',
+  projectBudgetMax: '项目预算上限',
+  projectBudgetRemainingAfter: '扣除后项目预算',
+  projectGroupName: '项目组名称',
+  projectGroupNo: '项目组编号',
+  projectId: 'AWB 项目 ID',
+  prompt: '提示词',
+  propCount: '道具数',
+  propKey: '道具 Key',
+  publicId: '公开任务 ID',
+  quality: '清晰度',
+  ratio: '宽高比',
+  registered: '已注册',
+  remoteTaskId: '远端任务 ID',
+  requestSource: '请求来源',
+  resourceConversion: '素材转换',
+  resourceConversionCount: '素材转换数',
+  resourceCount: '素材数',
+  resultCount: '结果数',
+  resultUrls: '结果链接',
+  reused: '已复用',
+  rowCount: '行数',
+  rowKind: '行类型',
+  saved: '已保存',
+  sceneCount: '场数',
+  sceneId: '场 ID',
+  selected: '已选择',
+  sortOrder: '排序',
+  source: '来源',
+  sourceFile: '来源文件',
+  sourceTaskId: '来源任务 ID',
+  stateKey: '状态 Key',
+  status: '状态',
+  statusCommandTaskType: '状态任务类型',
+  submitted: '已提交',
+  successRate: '成功率',
+  subjectId: '主体 ID',
+  taskCount: '任务数',
+  taskId: '任务 ID',
+  taskQueueNum: '排队数',
+  taskStatus: '任务状态',
+  taskType: '任务类型',
+  timedOut: '已超时',
+  title: '标题',
+  updated: '已更新',
+  userId: '用户 ID',
+  userName: '用户名',
+  verification: '验证方式',
+  verified: '已验证',
+  verify: '联网验证',
+  verifyCommand: '验证命令',
+  videoEpisodeId: '视频集 ID',
+  voiceId: '音色 ID',
+  voiceName: '音色名称',
+  voiceRecordId: '音色记录 ID',
+  voiceUrl: '音频地址',
+  apiOrigin: 'API 地址',
+  authState: '认证状态',
+  cli: 'CLI',
+  commandCount: '命令数',
+  commandFilter: '命令过滤',
+  commonFieldCount: '通用字段数',
+  domainFilter: '领域过滤',
+  nodeVersion: 'Node 版本',
+  resourceFieldCount: '资源字段数',
+  resourceRuleCount: '资源规则数',
+  schemaVersion: 'Schema 版本',
+  version: '版本',
+  type: '类型',
+  message: '消息',
+  hint: '提示',
+  unknownOptions: '未知参数',
+  note: '说明',
+  commandPrefix: '命令前缀',
+  elementDescription: '主体描述',
+  elementFrontalImage: '主体正面图',
+  elementName: '主体名称',
+  referenceType: '引用类型',
+  remoteUpload: '远程上传',
+  remoteUrl: '远程地址',
+};
+
+const DETAIL_FIELDS_BY_KIND = {
+  account_summary: ['userId', 'userName', 'groupId', 'groupName', 'currentProjectGroupNo', 'currentProjectGroupName', 'billingPointBalance', 'projectBudgetBalance', 'projectBudgetMax'],
+  artifact_delete_result: ['deleted', 'action', 'projectId', 'rowKind', 'entityKey', 'key', 'stateKey', 'episodeId', 'sceneId', 'clipId', 'videoEpisodeId'],
+  artifact_full: ['projectId', 'id', 'title', 'status', 'rowCount', 'actorCount', 'propCount', 'locationCount', 'episodeCount', 'sceneCount', 'clipCount'],
+  artifact_import_result: ['imported', 'dryRun', 'action', 'projectId', 'sourceFile', 'inputDir', 'inputFile', 'rowCount', 'actorCount', 'propCount', 'locationCount', 'episodeCount', 'sceneCount', 'clipCount', 'batchCount'],
+  artifact_record: ['id', 'projectId', 'rowKind', 'entityKey', 'parentKey', 'actorKey', 'propKey', 'locationKey', 'stateKey', 'episodeId', 'sceneId', 'clipId', 'videoEpisodeId', 'status', 'title', 'name', 'displayName', 'description'],
+  artifact_status_update: ['updated', 'videoEpisodeId', 'status', 'messageCount'],
+  artifact_write_result: ['id', 'projectId', 'rowKind', 'entityKey', 'parentKey', 'actorKey', 'propKey', 'locationKey', 'stateKey', 'episodeId', 'sceneId', 'clipId', 'videoEpisodeId', 'status', 'title', 'name', 'displayName'],
+  asset_group_detail: ['groupId', 'platform', 'name', 'projectName', 'description', 'status', 'assetCount'],
+  asset_group_write_result: ['created', 'updated', 'groupId', 'platform', 'name', 'projectName', 'assetPath'],
+  asset_register_result: ['created', 'updated', 'registered', 'assetId', 'groupId', 'platform', 'name', 'projectName', 'assetPath', 'uploadBackendPath', 'uploadUrl'],
+  auth_result: ['saved', 'verified', 'accessKey', 'source', 'dryRun', 'userId', 'userName', 'groupId', 'groupName'],
+  auth_status: ['configured', 'authType', 'accessKey', 'source', 'verified', 'verification', 'verifyCommand', 'userId', 'userName', 'groupId', 'groupName'],
+  batch_subject_publish_result: ['dryRun', 'submitted', 'count', 'successCount', 'failureCount', 'modelCode', 'projectGroupNo'],
+  batch_task_status: ['count', 'taskCount', 'successTaskCount', 'resultCount', 'pointTotal', 'timedOut', 'waitedMs'],
+  batch_task_submission: ['dryRun', 'submitted', 'count', 'taskCount', 'successCount', 'failureCount', 'modelGroupCode', 'projectGroupNo', 'pointCost', 'billingPointBalance', 'projectBudgetBalance'],
+  credits_balance: ['billingPointBalance', 'currentProjectGroupNo', 'currentProjectGroupName', 'projectBudgetBalance', 'projectBudgetMax'],
+  credits_usage: ['projectGroupNo', 'sinceText', 'untilText', 'scannedTaskCount', 'pointTotal'],
+  environment_report: ['doctorStatus', 'verify'],
+  fee_estimate: ['modelGroupCode', 'projectGroupNo', 'pointCost', 'billingPointBalance', 'billingPointRemainingAfter', 'projectBudgetBalance', 'projectBudgetMax', 'projectBudgetRemainingAfter'],
+  generic: ['cleared', 'selected', 'created', 'updated', 'reused', 'dryRun', 'action', 'projectGroupNo', 'projectGroupName', 'groupId', 'groupName', 'projectGroupName', 'point', 'memberCount', 'note'],
+  local_task_records: ['count', 'taskCount', 'successTaskCount', 'resultCount', 'pointTotal'],
+  project_summary: ['selected', 'created', 'updated', 'reused', 'projectGroupNo', 'projectGroupName', 'isSelected', 'projectBudgetBalance', 'projectBudgetMax', 'memberCount'],
+  subject_publish_result: ['created', 'name', 'elementId', 'subjectId', 'externalId', 'modelCode', 'status', 'taskStatus', 'errorMessage', 'nextRefSubject'],
+  subject_status: ['name', 'elementId', 'subjectId', 'externalId', 'modelCode', 'status', 'taskStatus', 'errorMessage', 'isTerminal', 'nextRefSubject'],
+  subject_voice_create_result: ['created', 'name', 'voiceRecordId', 'reqTaskId', 'voiceId', 'externalId', 'status', 'taskStatus', 'errorMessage', 'nextVoiceArg'],
+  subject_voice_status: ['name', 'voiceRecordId', 'reqTaskId', 'voiceId', 'externalId', 'status', 'taskStatus', 'errorMessage', 'isTerminal', 'nextVoiceArg'],
+  subtitle_task_status: ['taskId', 'publicId', 'remoteTaskId', 'taskType', 'taskStatus', 'isTerminal', 'projectGroupNo', 'resultCount', 'errorMessage', 'timedOut', 'waitedMs'],
+  subtitle_task_submission: ['submitted', 'taskId', 'taskType', 'sourceTaskId', 'projectGroupNo', 'pointCost', 'billingPointBalance', 'billingPointRemainingAfter', 'projectBudgetBalance', 'projectBudgetMax', 'projectBudgetRemainingAfter', 'nextCommand'],
+  task_status: ['taskId', 'publicId', 'remoteTaskId', 'taskType', 'taskStatus', 'isTerminal', 'modelGroupCode', 'projectGroupNo', 'pointNo', 'gmtCreate', 'resultCount', 'errorMessage', 'timedOut', 'waitedMs'],
+  task_submission: ['taskId', 'taskType', 'modelGroupCode', 'projectGroupNo', 'pointNo', 'points', 'pointCost', 'billingPointBalance', 'billingPointRemainingAfter', 'projectBudgetBalance', 'projectBudgetMax', 'projectBudgetRemainingAfter', 'uploadCount', 'nextCommand'],
+  upload_result: ['dryRun', 'fileCount', 'assetCount', 'localFileCount', 'resourceConversionCount'],
+};
+
+const DRY_RUN_FIELDS_BY_COMMAND = {
+  'auth login': ['dryRun', 'saved', 'verified', 'accessKey'],
+  'auth clear': ['dryRun', 'action', 'cleared'],
+  'account switch-team': ['dryRun', 'action', 'groupId', 'selected'],
+  'project use': ['dryRun', 'action', 'projectGroupNo', 'selected'],
+  'project create': ['dryRun', 'action', 'projectGroupName', 'point', 'memberCount', 'note'],
+  'project update': ['dryRun', 'action', 'projectGroupNo', 'projectGroupName', 'point', 'memberCount'],
+  'project ensure': ['dryRun', 'action', 'projectGroupName', 'point', 'memberCount', 'note'],
+  'upload files': ['dryRun', 'fileCount', 'localFileCount', 'resourceConversionCount'],
+  'create image': ['dryRun', 'action', 'modelGroupCode', 'projectGroupNo', 'prompt', 'ratio', 'quality', 'generateNum', 'resourceCount', 'localFileCount', 'assetCount'],
+  'create video': ['dryRun', 'action', 'modelGroupCode', 'projectGroupNo', 'prompt', 'duration', 'ratio', 'quality', 'needAudio', 'resourceCount', 'localFileCount', 'assetCount'],
+  'create image-batch': ['dryRun', 'count', 'modelGroupCode', 'projectGroupNo'],
+  'create video-batch': ['dryRun', 'count', 'modelGroupCode', 'projectGroupNo'],
+  'create video-subtitle-removal': ['dryRun', 'action', 'sourceTaskId', 'projectGroupNo'],
+  'create asset-group': ['dryRun', 'action', 'platform', 'name', 'projectName'],
+  'create asset-group-update': ['dryRun', 'action', 'groupId', 'platform', 'name', 'projectName'],
+  'create asset': ['dryRun', 'action', 'groupId', 'platform', 'name', 'assetPath', 'localFileCount', 'fileCount'],
+  'create subject': ['dryRun', 'action', 'name', 'modelCode', 'elementFrontalImage', 'assetCount', 'localFileCount', 'nextRefSubject'],
+  'create subject-voice': ['dryRun', 'action', 'name', 'voiceName', 'voiceUrl', 'remoteUrl', 'remoteUpload', 'localFileCount', 'nextVoiceArg'],
+  'create subject-batch': ['dryRun', 'count', 'modelCode'],
+  'artifact script import': ['dryRun', 'action', 'projectId', 'sourceFile', 'inputFile', 'rowCount', 'actorCount', 'episodeCount', 'sceneCount', 'clipCount'],
+  'artifact asset import': ['dryRun', 'action', 'projectId', 'inputDir', 'actorCount', 'propCount', 'locationCount'],
+  'artifact video import-storyboard': ['dryRun', 'action', 'projectId', 'inputFile', 'episodeId', 'sceneCount', 'clipCount'],
+  'artifact clip upsert-batch': ['dryRun', 'action', 'projectId', 'episodeCount'],
+  'artifact clip update-status': ['dryRun', 'action', 'projectId', 'videoEpisodeId', 'status', 'messageCount'],
+};
+
+const LIST_KEY_BY_KIND = {
+  artifact_list: 'items',
+  asset_group_list: 'groups',
+  asset_match_list: 'matches',
+  asset_review_model_list: 'models',
+  batch_subject_publish_result: 'results',
+  batch_task_status: 'records',
+  batch_task_submission: 'results',
+  command_schema: 'commands',
+  credits_usage: 'buckets',
+  local_task_records: 'records',
+  model_list: 'models',
+  project_list: 'projectGroups',
+  project_user_list: 'users',
+  subject_list: 'subjects',
+  subject_voice_list: 'voices',
+  task_list: 'tasks',
+  team_list: 'teams',
+  upload_result: 'files',
+};
+
+const PRETTY_KIND_PROFILES = Object.fromEntries(Object.keys(KIND_TITLES).map((kind) => [kind, {
+  title: KIND_TITLES[kind],
+  fields: DETAIL_FIELDS_BY_KIND[kind] || [],
+  listKey: LIST_KEY_BY_KIND[kind],
+}]));
+
+export const PRETTY_OUTPUT_KIND_COVERAGE = Object.freeze(Object.keys(PRETTY_KIND_PROFILES));
+
+function outputKindForCommand(commandName, context = {}) {
+  return context.outputKind || OUTPUT_KIND_BY_COMMAND[commandName] || 'generic';
+}
+
+function prettyTitle(commandName, kind, data) {
+  const base = COMMAND_TITLES[commandName] || PRETTY_KIND_PROFILES[kind]?.title || KIND_TITLES[kind] || '命令结果';
+  const title = commandName === 'schema' && data?.kind === 'agent_brief' ? 'Agent 能力摘要' : base;
+  return titleText(data?.dryRun ? `${title}（预览）` : title);
+}
+
+function stripAnsi(value) {
+  return String(value ?? '').replace(/\u001b\[[0-9;]*m/g, '');
+}
+
+function charDisplayWidth(char) {
+  const code = char.codePointAt(0);
+  if (code === 0) return 0;
+  if (code < 32 || (code >= 0x7f && code < 0xa0)) return 0;
+  return (
+    code >= 0x1100
+    && (code <= 0x115f
+      || code === 0x2329
+      || code === 0x232a
+      || (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f)
+      || (code >= 0xac00 && code <= 0xd7a3)
+      || (code >= 0xf900 && code <= 0xfaff)
+      || (code >= 0xfe10 && code <= 0xfe19)
+      || (code >= 0xfe30 && code <= 0xfe6f)
+      || (code >= 0xff00 && code <= 0xff60)
+      || (code >= 0xffe0 && code <= 0xffe6))
+  ) ? 2 : 1;
+}
+
+function displayWidth(value) {
+  let width = 0;
+  for (const char of stripAnsi(value)) width += charDisplayWidth(char);
+  return width;
+}
+
+function truncateDisplay(value, maxWidth = 32) {
+  const text = String(value ?? '');
+  if (displayWidth(text) <= maxWidth) return text;
+  const marker = '...';
+  const markerWidth = displayWidth(marker);
+  let width = 0;
+  let out = '';
+  for (const char of text) {
+    const charWidth = charDisplayWidth(char);
+    if (width + charWidth + markerWidth > maxWidth) break;
+    out += char;
+    width += charWidth;
+  }
+  return `${out}${marker}`;
+}
+
+function wrapDisplay(value, width) {
+  const maxWidth = Math.max(1, width);
+  const text = String(value ?? '');
+  const lines = [];
+  const pushHardWrapped = (chunk, state) => {
+    for (const char of chunk) {
+      const charWidth = charDisplayWidth(char);
+      if (state.lineWidth > 0 && state.lineWidth + charWidth > maxWidth) {
+        lines.push(state.line);
+        state.line = char;
+        state.lineWidth = charWidth;
+      } else {
+        state.line += char;
+        state.lineWidth += charWidth;
+      }
+    }
+  };
+  const tokenBoundary = (char) => /[\s、，,;；|/\\_-]/u.test(char);
+  for (const segment of text.split(/\r?\n/)) {
+    if (!segment) {
+      lines.push('');
+      continue;
+    }
+    const state = { line: '', lineWidth: 0 };
+    let token = '';
+    const flushToken = () => {
+      if (!token) return;
+      const tokenWidth = displayWidth(token);
+      if (tokenWidth > maxWidth) {
+        pushHardWrapped(token, state);
+      } else if (state.lineWidth > 0 && state.lineWidth + tokenWidth > maxWidth) {
+        lines.push(state.line);
+        state.line = token.trimStart();
+        state.lineWidth = displayWidth(state.line);
+      } else {
+        state.line += token;
+        state.lineWidth += tokenWidth;
+      }
+      token = '';
+    };
+    for (const char of segment) {
+      token += char;
+      if (tokenBoundary(char)) flushToken();
+    }
+    flushToken();
+    lines.push(state.line);
+  }
+  return lines.length ? lines : [''];
+}
+
+function padDisplay(value, width) {
+  const text = String(value ?? '');
+  return `${text}${' '.repeat(Math.max(0, width - displayWidth(text)))}`;
+}
+
+function shouldColorOutput() {
+  if (String(process.env.LINGJING_AWB_COLOR || '').toLowerCase() === '0') return false;
+  if (String(process.env.LINGJING_AWB_COLOR || '').toLowerCase() === 'false') return false;
+  if (String(process.env.FORCE_COLOR || '').trim() && process.env.FORCE_COLOR !== '0') return true;
+  if (String(process.env.LINGJING_AWB_COLOR || '').toLowerCase() === '1') return true;
+  if (String(process.env.LINGJING_AWB_COLOR || '').toLowerCase() === 'true') return true;
+  if (process.env.NO_COLOR) return false;
+  return Boolean(process.stdout.isTTY);
+}
+
+function colorText(value, code) {
+  const text = String(value ?? '');
+  if (!shouldColorOutput() || !text) return text;
+  const colorMatch = String(code).match(/38;5;(\d+)/);
+  let rendered = colorMatch ? CHALK.ansi256(Number(colorMatch[1]))(text) : text;
+  if (String(code).includes('36')) rendered = CHALK.cyan(text);
+  if (String(code).split(';').includes('1')) rendered = CHALK.bold(rendered);
+  if (String(code).split(';').includes('2')) rendered = CHALK.dim(rendered);
+  return rendered;
+}
+
+const COLOR = {
+  title: '1;38;5;39',
+  accent: '1;38;5;208',
+  section: '1;38;5;75',
+  border: '38;5;238',
+  header: '1;38;5;81',
+  label: '38;5;215',
+  value: '38;5;250',
+  command: '38;5;82',
+  code: '38;5;111',
+  success: '38;5;82',
+  warning: '38;5;220',
+  danger: '38;5;203',
+  muted: '2;38;5;245',
+};
+
+function titleText(value) {
+  if (!shouldColorOutput()) return String(value ?? '');
+  return `${colorText('◆', COLOR.accent)} ${colorText(value, COLOR.title)}`;
+}
+
+function errorTitleText(value) {
+  if (!shouldColorOutput()) return String(value ?? '');
+  return `${colorText('◆', COLOR.danger)} ${colorText(value, '1;38;5;203')}`;
+}
+
+function sectionText(value) {
+  if (!shouldColorOutput()) return String(value ?? '');
+  return `${colorText('▸', COLOR.accent)} ${colorText(value, COLOR.section)}`;
+}
+
+function borderText(value) {
+  return colorText(value, COLOR.border);
+}
+
+function headerText(value) {
+  return colorText(value, COLOR.header);
+}
+
+function labelText(value) {
+  return colorText(value, COLOR.label);
+}
+
+function mutedText(value) {
+  return colorText(value, COLOR.muted);
+}
+
+function commandText(value) {
+  return colorText(value, COLOR.command);
+}
+
+function codeText(value) {
+  return colorText(value, COLOR.code);
+}
+
+function semanticText(value) {
+  const text = String(value ?? '');
+  if (!shouldColorOutput() || !text) return text;
+  const plain = stripAnsi(text).trim().toLowerCase();
+  if (/^(是|true|success|succeeded|completed|done|ok|healthy|passed|enabled|active|已配置|已登录|成功)$/.test(plain)) {
+    return colorText(text, COLOR.success);
+  }
+  if (/^(否|false|pending|running|processing|queued|warning|warn|dry-run|dryrun|预览|缓存过期|未登录|未选择|未知)$/.test(plain)) {
+    return colorText(text, COLOR.warning);
+  }
+  if (/^(failed|failure|error|errored|fatal|invalid|denied|rejected|deleted|失败|错误|无效|删除)$/.test(plain)) {
+    return colorText(text, COLOR.danger);
+  }
+  return text;
+}
+
+function prettyCellText(value, columnInfo = {}) {
+  const text = String(value ?? '');
+  if (!shouldColorOutput() || !text) return text;
+  const header = stripAnsi(columnInfo.header || '');
+  if (header === '#' || columnInfo.index) return mutedText(text);
+  if (['状态', '当前', '必填', '验证', 'WebP'].includes(header)) return semanticText(text);
+  if (['CLI', '命令', '继续查询', '生成创建写法'].includes(header) || stripAnsi(text).startsWith('--')) return codeText(text);
+  if (stripAnsi(text).startsWith(commandPrefix())) return commandText(text);
+  if (['队列', '排队数', '成功率', '结果数', '任务数', '积分', '数量', '文件数'].includes(header)) return colorText(text, COLOR.accent);
+  return text;
+}
+
+function prettyDetailValue(value, label = '') {
+  const text = String(value ?? '');
+  if (!shouldColorOutput() || !text) return text;
+  if (/命令|写法|CLI|JSON|Agent|Dry-run|继续|确认|执行/.test(label) || stripAnsi(text).startsWith(commandPrefix())) {
+    return commandText(text);
+  }
+  if (/状态|验证|当前|必填|已/.test(label)) return semanticText(text);
+  return colorText(text, COLOR.value);
+}
+
+function humanizeKey(key) {
+  if (FIELD_LABELS[key]) return FIELD_LABELS[key];
+  return String(key || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[_-]+/g, ' ')
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+function prettyBoolean(value) {
+  return value ? '是' : '否';
+}
+
+function prettyValue(value, options = {}) {
+  if (value === undefined || value === null || value === '') return '';
+  if (typeof value === 'boolean') return prettyBoolean(value);
+  if (Array.isArray(value)) {
+    if (!value.length) return '无';
+    if (value.every((item) => !isPlainObject(item) && !Array.isArray(item))) return value.map((item) => prettyValue(item)).join('、');
+    return `${value.length} 项`;
+  }
+  if (isPlainObject(value)) {
+    const summary = renderRecord(compactRecord(value), options.objectKeys || []);
+    return summary || JSON.stringify(value);
+  }
+  return rewriteCommandPrefix(value);
+}
+
+function resolveColumnValue(row, column) {
+  if (typeof column.value === 'function') return column.value(row);
+  if (typeof column.key === 'function') return column.key(row);
+  if (Array.isArray(column.key)) {
+    for (const key of column.key) {
+      if (row?.[key] !== undefined && row?.[key] !== null && row?.[key] !== '') return row[key];
+    }
+    return undefined;
+  }
+  return row?.[column.key];
+}
+
+function column(header, key, options = {}) {
+  return { header, key, ...options };
+}
+
+function joinValueList(value, limit = 6) {
+  if (!Array.isArray(value)) return prettyValue(value);
+  return valueList(value, limit)?.replaceAll('|', '、') || '';
+}
+
+const TABLE_COLUMNS = {
+  assets: [
+    column('标签', 'label', { maxWidth: 14 }),
+    column('引用类型', ['referenceType', 'type'], { maxWidth: 16 }),
+    column('用途', 'usage', { maxWidth: 16 }),
+    column('路径', 'assetPath', { maxWidth: 42 }),
+    column('素材 ID', 'assetId', { maxWidth: 22 }),
+  ],
+  buckets: [
+    column('任务类型', 'taskType', { maxWidth: 24 }),
+    column('任务数', 'taskCount', { maxWidth: 10 }),
+    column('成功数', 'successTaskCount', { maxWidth: 10 }),
+    column('结果数', 'resultCount', { maxWidth: 10 }),
+    column('积分', 'pointTotal', { maxWidth: 10 }),
+  ],
+  checks: [
+    column('检查项', 'name', { maxWidth: 18 }),
+    column('状态', 'status', { maxWidth: 12 }),
+    column('说明', 'message', { maxWidth: 58 }),
+  ],
+  commands: [
+    column('命令', 'name', { maxWidth: 34 }),
+    column('领域', 'domain', { maxWidth: 12 }),
+    column('输出', (row) => row.workflow?.outputKind, { maxWidth: 24 }),
+    column('安全', (row) => (row.safety?.safeToAutoRun ? '可自动运行' : '需确认/写入'), { maxWidth: 14 }),
+    column('说明', 'summary', { maxWidth: 44 }),
+  ],
+  domains: [
+    column('领域', 'name', { maxWidth: 14 }),
+    column('命令数', 'commandCount', { maxWidth: 10 }),
+    column('说明', 'description', { maxWidth: 60 }),
+  ],
+  files: [
+    column('文件', ['filePath', 'path', 'fileName'], { maxWidth: 38 }),
+    column('场景', 'sceneType', { maxWidth: 24 }),
+    column('类型', ['mimeType', 'mime'], { maxWidth: 18 }),
+    column('大小', 'size', { maxWidth: 10 }),
+    column('后端路径', ['backendPath', 'url'], { maxWidth: 42 }),
+  ],
+  groups: [
+    column('组 ID', 'groupId', { maxWidth: 24 }),
+    column('平台', 'platform', { maxWidth: 12 }),
+    column('名称', 'name', { maxWidth: 24 }),
+    column('项目名', 'projectName', { maxWidth: 24 }),
+    column('状态', 'status', { maxWidth: 14 }),
+  ],
+  items: [
+    column('ID', ['id', 'entityKey', 'key'], { maxWidth: 24 }),
+    column('类型', ['rowKind', 'assetKind'], { maxWidth: 16 }),
+    column('名称', ['title', 'name', 'displayName'], { maxWidth: 30 }),
+    column('父级', 'parentKey', { maxWidth: 22 }),
+    column('状态', 'status', { maxWidth: 16 }),
+    column('说明', 'description', { maxWidth: 42 }),
+  ],
+  localFiles: [
+    column('文件', ['path', 'filePath', 'fileName'], { maxWidth: 42 }),
+    column('存在', 'exists', { maxWidth: 8 }),
+    column('类型', ['mimeType', 'mime'], { maxWidth: 18 }),
+    column('大小', 'size', { maxWidth: 10 }),
+  ],
+  matches: [
+    column('素材 ID', 'assetId', { maxWidth: 22 }),
+    column('名称', ['name', 'assetName'], { maxWidth: 24 }),
+    column('分数', 'score', { maxWidth: 8 }),
+    column('图片', 'imageUrl', { maxWidth: 42 }),
+  ],
+  models: [
+    column('模型组', 'modelGroupCode', { maxWidth: 34 }),
+    column('名称', ['displayName', 'modelName'], { maxWidth: 24 }),
+    column('说明', 'modelDesc', { maxWidth: 34 }),
+    column('排队数', 'taskQueueNum', { maxWidth: 8 }),
+    column('成功率', (row) => formatPercent(row.successRate), { maxWidth: 8 }),
+    column('输入', (row) => joinValueList(row.inputModes), { maxWidth: 28 }),
+    column('参数', (row) => joinValueList(row.params), { maxWidth: 24 }),
+    column('素材', (row) => joinValueList(row.resourceParams), { maxWidth: 24 }),
+  ],
+  params: [
+    column('参数', 'key', { maxWidth: 22 }),
+    column('类型', 'valueType', { maxWidth: 12 }),
+    column('可选值', (row) => joinValueList(row.values, 8), { maxWidth: 42 }),
+    column('默认', 'defaultValue', { maxWidth: 14 }),
+    column('必填', 'required', { maxWidth: 8 }),
+  ],
+  projectGroups: [
+    column('项目组编号', 'projectGroupNo', { maxWidth: 24 }),
+    column('名称', 'projectGroupName', { maxWidth: 28 }),
+    column('当前', 'isSelected', { maxWidth: 8 }),
+    column('预算余额', ['projectBudgetBalance', 'projectPointBalance'], { maxWidth: 12 }),
+    column('成员', 'memberCount', { maxWidth: 8 }),
+  ],
+  records: [
+    column('任务 ID', ['taskId', 'publicId', 'remoteTaskId'], { maxWidth: 28 }),
+    column('类型', 'taskType', { maxWidth: 20 }),
+    column('状态', ['taskStatus', 'status'], { maxWidth: 16 }),
+    column('模型', 'modelGroupCode', { maxWidth: 30 }),
+    column('结果数', 'resultCount', { maxWidth: 8 }),
+    column('记录时间', ['recordedAt', 'gmtCreate', 'createdAt'], { maxWidth: 22 }),
+  ],
+  resources: [
+    column('模式', 'mode', { maxWidth: 16 }),
+    column('媒体', 'mediaType', { maxWidth: 10 }),
+    column('用途', (row) => joinValueList(row.usage), { maxWidth: 26 }),
+    column('输入形态', (row) => textValueShapes(row.valueShapes)?.replaceAll('|', '、'), { maxWidth: 28 }),
+    column('格式', (row) => textResourceFormats(row)?.replaceAll('|', '、'), { maxWidth: 28 }),
+    column('文件数', (row) => textFileCount(row), { maxWidth: 10 }),
+    column('WebP', (row) => textWebpInput(row), { maxWidth: 18 }),
+  ],
+  results: [
+    column('序号', 'inputIndex', { maxWidth: 8 }),
+    column('状态', ['status', 'taskStatus'], { maxWidth: 16 }),
+    column('任务 ID', 'taskId', { maxWidth: 28 }),
+    column('模型/主体', ['modelGroupCode', 'modelCode', 'name'], { maxWidth: 30 }),
+    column('说明', ['message', 'errorMessage', 'prompt'], { maxWidth: 42 }),
+  ],
+  subjects: [
+    column('主体 ID', ['elementId', 'subjectId'], { maxWidth: 24 }),
+    column('名称', 'name', { maxWidth: 24 }),
+    column('模型', 'modelCode', { maxWidth: 14 }),
+    column('外部 ID', 'externalId', { maxWidth: 24 }),
+    column('状态', ['status', 'taskStatus'], { maxWidth: 14 }),
+  ],
+  tasks: [
+    column('任务 ID', ['taskId', 'publicId', 'remoteTaskId'], { maxWidth: 28 }),
+    column('类型', 'taskType', { maxWidth: 20 }),
+    column('状态', 'taskStatus', { maxWidth: 16 }),
+    column('模型', 'modelGroupCode', { maxWidth: 30 }),
+    column('结果数', 'resultCount', { maxWidth: 8 }),
+    column('创建时间', 'gmtCreate', { maxWidth: 22 }),
+  ],
+  teams: [
+    column('团队 ID', 'groupId', { maxWidth: 22 }),
+    column('团队名称', 'groupName', { maxWidth: 28 }),
+    column('当前', ['currentGroup', 'isSelected'], { maxWidth: 8 }),
+    column('角色', 'role', { maxWidth: 14 }),
+  ],
+  users: [
+    column('用户 ID', 'userId', { maxWidth: 22 }),
+    column('用户名', 'userName', { maxWidth: 24 }),
+    column('角色', 'role', { maxWidth: 14 }),
+    column('当前', ['currentGroup', 'isCheck'], { maxWidth: 8 }),
+  ],
+  voices: [
+    column('音色记录 ID', ['voiceRecordId', 'reqTaskId'], { maxWidth: 26 }),
+    column('名称', 'name', { maxWidth: 24 }),
+    column('音色 ID', ['voiceId', 'externalId'], { maxWidth: 24 }),
+    column('状态', ['status', 'taskStatus'], { maxWidth: 14 }),
+  ],
+};
+
+function inferTableColumns(rows = []) {
+  const first = rows.find((row) => isPlainObject(row));
+  if (!first) return [column('值', (row) => prettyValue(row), { maxWidth: 70 })];
+  const preferred = [
+    'id',
+    'taskId',
+    'publicId',
+    'modelGroupCode',
+    'projectGroupNo',
+    'projectId',
+    'rowKind',
+    'entityKey',
+    'name',
+    'displayName',
+    'title',
+    'status',
+    'taskStatus',
+    'resultCount',
+    'errorMessage',
+  ];
+  const keys = [
+    ...preferred.filter((key) => first[key] !== undefined),
+    ...Object.keys(first).filter((key) => !preferred.includes(key) && !Array.isArray(first[key]) && !isPlainObject(first[key])),
+  ].slice(0, 6);
+  return keys.map((key) => column(humanizeKey(key), key, { maxWidth: key.toLowerCase().includes('url') ? 42 : 28 }));
+}
+
+function renderPrettyTable(rows = [], columns = [], options = {}) {
+  const tableRows = Array.isArray(rows) ? rows : [];
+  if (!tableRows.length) return [`  ${mutedText(options.emptyText || '无记录')}`];
+  const rawCols = columns.length ? columns : inferTableColumns(tableRows);
+  const rawRows = tableRows.map((row, index) => rawCols.map((col) => {
+    const raw = col.index ? index + 1 : resolveColumnValue(row, col);
+    const value = String(prettyValue(raw)).replace(/\r\n/g, '\n');
+    return value;
+  }));
+  const visibleColumnIndexes = rawCols
+    .map((col, index) => ({ col, index }))
+    .filter(({ col, index }) => col.always || rawCols.length === 1 || rawRows.some((row) => row[index] !== ''))
+    .map(({ index }) => index);
+  if (!visibleColumnIndexes.length) {
+    visibleColumnIndexes.push(...rawCols.map((_, index) => index));
+  }
+  const cols = visibleColumnIndexes.map((index) => rawCols[index]);
+  const headerCells = cols.map((col) => col.header);
+  const bodyRows = rawRows.map((row) => visibleColumnIndexes.map((index) => row[index]));
+  const widths = cols.map((col, colIndex) => {
+    const values = [headerCells[colIndex], ...bodyRows.map((row) => row[colIndex])];
+    const max = Math.max(...values.map(displayWidth));
+    return Math.max(col.minWidth || 4, Math.min(col.maxWidth || 30, max));
+  });
+  const renderedRows = bodyRows.map((row, rowIndex) => row.map((cell, colIndex) => {
+    const wrapped = wrapDisplay(cell, widths[colIndex]).join('\n');
+    return prettyCellText(wrapped, { ...cols[colIndex], rowIndex });
+  }));
+  const table = new Table({
+    head: headerCells.map((cell) => headerText(cell)),
+    colWidths: widths.map((width) => width + 2),
+    wordWrap: false,
+    truncate: '',
+    style: {
+      head: [],
+      border: [],
+      compact: false,
+      'padding-left': 1,
+      'padding-right': 1,
+    },
+  });
+  table.push(...renderedRows);
+  return table.toString()
+    .split('\n')
+    .map((line) => line.replace(/[┌┬┐├┼┤└┴┘│─]/g, (char) => borderText(char)));
+}
+
+function sectionTitle(lines, title) {
+  if (lines.length && lines[lines.length - 1] !== '') lines.push('');
+  lines.push(sectionText(title));
+}
+
+function detailRows(record, preferredKeys = [], excludedKeys = [], options = {}) {
+  if (!isPlainObject(record)) return [];
+  const excluded = new Set(excludedKeys);
+  const preferred = preferredKeys.filter((key) => !excluded.has(key) && record[key] !== undefined && record[key] !== null && record[key] !== '');
+  const fallback = options.includeRest
+    ? Object.keys(record).filter((key) => {
+      if (excluded.has(key) || preferredKeys.includes(key)) return false;
+      const value = record[key];
+      if (value === undefined || value === null || value === '') return false;
+      if (Array.isArray(value) || isPlainObject(value)) return false;
+      return true;
+    })
+    : [];
+  const keys = [...preferred, ...fallback];
+  return keys.map((key) => ({ label: humanizeKey(key), value: record[key] }));
+}
+
+function renderDetails(lines, title, record, preferredKeys = [], excludedKeys = [], options = {}) {
+  const rows = detailRows(record, preferredKeys, excludedKeys, options);
+  if (!rows.length) return;
+  sectionTitle(lines, title);
+  const labelWidth = Math.min(22, Math.max(...rows.map((row) => displayWidth(row.label))));
+  for (const row of rows) {
+    const value = String(prettyValue(row.value)).replace(/\s*\r?\n\s*/g, ' ');
+    const valueLines = wrapDisplay(value, options.valueWidth || 96);
+    for (const [index, valueLine] of valueLines.entries()) {
+      const label = index === 0 ? row.label : '';
+      lines.push(`  ${labelText(padDisplay(label, labelWidth))}  ${prettyDetailValue(valueLine, row.label)}`);
+    }
+  }
+}
+
+function renderArraySection(lines, title, rows, listKey, limit = Number.POSITIVE_INFINITY) {
+  if (!Array.isArray(rows) || !rows.length) return;
+  const visibleRows = rows.slice(0, Number.isFinite(limit) ? limit : rows.length);
+  sectionTitle(lines, `${title}（${rows.length}）`);
+  const columns = Array.isArray(listKey) ? listKey : (TABLE_COLUMNS[listKey] || inferTableColumns(visibleRows));
+  lines.push(...renderPrettyTable(visibleRows, columns));
+  if (rows.length > visibleRows.length) lines.push(`  ${mutedText(`还有 ${rows.length - visibleRows.length} 条未展示；使用 --all 或 -f json 查看完整数据。`)}`);
+}
+
+function renderScalarList(lines, title, values = [], limit = 8) {
+  if (!Array.isArray(values) || !values.length) return;
+  sectionTitle(lines, `${title}（${values.length}）`);
+  for (const [index, value] of values.slice(0, limit).entries()) {
+    lines.push(`  ${mutedText(`${index + 1}.`)} ${prettyDetailValue(prettyValue(value), title)}`);
+  }
+  if (values.length > limit) lines.push(`  ${mutedText(`还有 ${values.length - limit} 项未展示；使用 -f json 查看完整数据。`)}`);
+}
+
+function namedListTitle(listKey) {
+  return {
+    assets: '素材',
+    buckets: '用量分组',
+    checks: '检查结果',
+    commands: '命令',
+    domains: '命令领域',
+    files: '文件',
+    groups: '素材组',
+    items: '记录',
+    localFiles: '本地文件',
+    matches: '匹配项',
+    models: '模型',
+    params: '参数',
+    projectGroups: '项目组',
+    records: '记录',
+    resources: '素材约束',
+    results: '结果',
+    subjects: '主体',
+    tasks: '任务',
+    teams: '团队',
+    users: '成员',
+    voices: '音色',
+  }[listKey] || humanizeKey(listKey);
+}
+
+function localizedTaskKind(value) {
+  if (value === 'image' || value === 'IMAGE_CREATE') return '图片生成';
+  if (value === 'video' || value === 'VIDEO_CREATE') return '视频生成';
+  return prettyValue(value);
+}
+
+function localizedInputMode(value, taskKind = '') {
+  const mode = String(value || '');
+  const isVideo = taskKind === 'video' || taskKind === 'VIDEO_CREATE';
+  const labels = {
+    prompt_only: isVideo ? '文本生成视频' : '文本生成图片',
+    reference: isVideo ? '参考素材生成' : '参考图生成',
+    frames: '首帧/尾帧生成',
+    storyboard: '分镜多镜头',
+    keyframe: '关键帧生成',
+  };
+  return labels[mode] || mode;
+}
+
+function localizedParamKey(value) {
+  const labels = {
+    ratio: '宽高比',
+    quality: '清晰度',
+    generateNum: '生成数量',
+    generate_num: '生成数量',
+    duration: '时长',
+    generated_time: '时长',
+    needAudio: '生成音频',
+    need_audio: '生成音频',
+    prompt_optimizer: '提示词增强',
+  };
+  return labels[value] || value;
+}
+
+function localizedParamType(value) {
+  const labels = {
+    enum: '枚举选择',
+    text: '文本',
+    string: '文本',
+    number: '数字',
+    integer: '整数',
+    boolean: '开关',
+    bool: '开关',
+  };
+  return labels[String(value || '').toLowerCase()] || value;
+}
+
+function cliFlagForParam(key) {
+  const flags = {
+    ratio: '--ratio',
+    quality: '--quality',
+    generateNum: '--generate-num',
+    generate_num: '--generate-num',
+    duration: '--duration',
+    generated_time: '--duration',
+    needAudio: '--need-audio',
+    need_audio: '--need-audio',
+    prompt: '--prompt',
+  };
+  return flags[key];
+}
+
+function localizedResourceParam(value) {
+  const labels = {
+    iref: '参考图',
+    cref: '角色参考',
+    sref: '风格参考',
+    resources: '统一素材',
+    frames: '首帧/尾帧',
+    multi_param: '多帧参数',
+    multi_prompt: '多段提示词',
+  };
+  return labels[value] || value;
+}
+
+function localizedMedia(value) {
+  const labels = {
+    IMAGE: '图片',
+    VIDEO: '视频',
+    AUDIO: '音频',
+    SUBJECT: '主体',
+  };
+  return labels[String(value || '').toUpperCase()] || prettyValue(value);
+}
+
+function localizedUsage(value) {
+  const labels = {
+    reference: '参考素材',
+    first_frame: '首帧',
+    last_frame: '尾帧',
+    keyframe: '关键帧',
+    prompt_only: '纯文本',
+    storyboard: '故事板',
+  };
+  if (Array.isArray(value)) return value.map((item) => localizedUsage(item)).join('、');
+  return labels[value] || prettyValue(value);
+}
+
+function localizedResourcePurpose(item = {}, taskKind = '') {
+  const modeText = localizedInputMode(item.mode, taskKind);
+  const usageText = localizedUsage(item.usage);
+  if (!usageText || usageText === '参考素材') return modeText;
+  if (!modeText) return usageText;
+  return `${modeText}（${usageText}）`;
+}
+
+function localizedResourceTarget(value, limits = {}) {
+  const text = String(value || '');
+  const match = text.match(/^resource\.([^.]+)\.([^.]+)(?:\.count)?$/);
+  if (!match) return '';
+  const [, media, usage] = match;
+  const mediaType = String(limits.mediaType || media).toUpperCase();
+  const usageText = localizedUsage(limits.usage || usage);
+  const mediaText = localizedMedia(mediaType);
+  if (usage === 'first_frame' || usage === 'last_frame') return `${usageText}${mediaText}`;
+  if (usage === 'frame') return `首帧/尾帧${mediaText}`;
+  if (usage === 'reference') return `参考${mediaText}`;
+  return `${usageText}${mediaText}`;
+}
+
+function localizedValueShape(value) {
+  const labels = {
+    local_file: '本地文件',
+    file: '本地文件',
+    http_url: 'URL',
+    url: 'URL',
+    backendPath: '平台素材路径',
+    platformPath: '平台素材路径',
+    asset_id: '资产 ID',
+    asset: '资产 ID',
+  };
+  return labels[value] || value;
+}
+
+function localizedInputShapes(values = []) {
+  const items = Array.isArray(values) ? values : [];
+  if (!items.length) return '';
+  return items.map(localizedValueShape).join('、');
+}
+
+function localizedFormats(item = {}) {
+  const formats = textResourceFormats(item);
+  return formats ? formats.replaceAll('|', '、') : '';
+}
+
+function localizedFileCount(item = {}) {
+  const value = textFileCount(item);
+  if (!value) return '';
+  if (value.startsWith('<=')) return `最多 ${value.slice(2)} 个`;
+  if (value.startsWith('>=')) return `至少 ${value.slice(2)} 个`;
+  if (value.includes('..')) return `${value.replace('..', '-')} 个`;
+  return `${value} 个`;
+}
+
+function localizedItemCount(item = {}) {
+  const value = textItemCount(item);
+  if (!value) return '';
+  if (value.startsWith('<=')) return `最多 ${value.slice(2)} 项`;
+  if (value.startsWith('>=')) return `至少 ${value.slice(2)} 项`;
+  if (value.includes('..')) return `${value.replace('..', '-')} 项`;
+  return `${value} 项`;
+}
+
+function formatKb(value) {
+  const kb = Number(value);
+  if (!Number.isFinite(kb)) return '';
+  if (kb >= 1024) {
+    const mb = kb / 1024;
+    return `${Number.isInteger(mb) ? mb : mb.toFixed(1)} MB`;
+  }
+  return `${kb} KB`;
+}
+
+function formatMs(value) {
+  const ms = Number(value);
+  if (!Number.isFinite(ms)) return '';
+  const seconds = ms / 1000;
+  if (seconds >= 1) return `${Number.isInteger(seconds) ? seconds : seconds.toFixed(1)} 秒`;
+  return `${ms} 毫秒`;
+}
+
+function localizedDurationRange(item = {}) {
+  if (item.minDurationMs != null && item.maxDurationMs != null) return `${formatMs(item.minDurationMs)}-${formatMs(item.maxDurationMs)}`;
+  if (item.maxDurationMs != null) return `最多 ${formatMs(item.maxDurationMs)}`;
+  if (item.minDurationMs != null) return `至少 ${formatMs(item.minDurationMs)}`;
+  return '';
+}
+
+function localizedTotalDuration(item = {}) {
+  if (item.maxTotalDurationMs == null) return '';
+  return `最多 ${formatMs(item.maxTotalDurationMs)}`;
+}
+
+function localizedWebpPolicy(item = {}) {
+  const value = textWebpInput(item);
+  if (value === 'accepted') return '支持 WebP';
+  if (String(value || '').startsWith('autoConvertTo')) return `WebP 自动转 ${String(value).replace('autoConvertTo', '')}`;
+  if (value === 'unsupported') return '不支持 WebP';
+  return '';
+}
+
+function localizedConditionKey(value) {
+  const resourceTarget = localizedResourceTarget(value);
+  if (resourceTarget && String(value || '').endsWith('.count')) return `${resourceTarget}数量`;
+  if (resourceTarget) return resourceTarget;
+  const labels = {
+    'resource.image.frame': '使用首帧/尾帧图片',
+    generatedMode: '生成方式',
+    ratio: '宽高比',
+    quality: '清晰度',
+    duration: '时长',
+    generated_time: '时长',
+  };
+  return labels[value] || localizedParamKey(value);
+}
+
+function localizedConditionValue(value) {
+  if (value === '__NOT_EMPTY__') return '已提供';
+  if (value === '__EMPTY__') return '未提供';
+  const labels = {
+    multi_param: '参考素材生成',
+    frames: '首帧/尾帧生成',
+    multi_prompt: '分镜多镜头',
+    prompt_only: '纯文本生成',
+  };
+  if (labels[value]) return labels[value];
+  return prettyValue(value);
+}
+
+function localizedCountRange(item = {}) {
+  const value = textCountRange(item);
+  if (!value) return '';
+  if (String(value).startsWith('>=')) return `至少 ${String(value).slice(2)} 个`;
+  if (String(value).startsWith('<=')) return `最多 ${String(value).slice(2)} 个`;
+  if (String(value).includes('..')) return `${String(value).replace('..', '-')} 个`;
+  return `${value} 个`;
+}
+
+function localizedConditions(conditions = []) {
+  if (!Array.isArray(conditions) || !conditions.length) return '';
+  return conditions
+    .map((item) => {
+      const key = item.key || item.configCode;
+      if (!key) return null;
+      if (item.meaning === 'count') return `${localizedConditionKey(key)}：${localizedCountRange(item)}`;
+      if (key === 'resource.image.frame' && item.meaning === 'present') return '首尾帧模式';
+      if (key === 'generatedMode' && item.value === 'multi_param') return '参考素材生成模式';
+      if (key === 'generatedMode' && item.value === 'frames') return '首帧/尾帧模式';
+      if (key === 'generatedMode' && item.value === 'multi_prompt') return '分镜多镜头模式';
+      return `${localizedConditionKey(key)}${localizedConditionValue(item.value) ? `：${localizedConditionValue(item.value)}` : ''}`;
+    })
+    .filter(Boolean)
+    .join('；');
+}
+
+function constraintHasCondition(item = {}, key, value = undefined) {
+  const conditions = Array.isArray(item.conditions) ? item.conditions : [];
+  return conditions.some((condition) => (
+    (condition.key || condition.configCode) === key
+    && (value === undefined || condition.value === value)
+  ));
+}
+
+function localizedConstraintResult(item = {}) {
+  const target = item.target || item.targetConfigCode;
+  const flag = cliFlagForParam(target);
+  if (item.effect === 'resource_limit_overrides') {
+    const limits = item.limits || {};
+    const subject = localizedResourceTarget(target, limits) || '素材';
+    const parts = [];
+    const count = localizedFileCount(limits);
+    const duration = localizedDurationRange(limits);
+    const totalDuration = localizedTotalDuration(limits);
+    const itemCount = localizedItemCount(limits);
+    if (count) parts.push(`${subject}${count}`);
+    if (duration) parts.push(`${subject}单个素材${duration}`);
+    if (totalDuration) parts.push(`${subject}总时长${totalDuration}`);
+    if (limits.maxSizeKB != null) parts.push(`${subject}单文件最多 ${formatKb(limits.maxSizeKB)}`);
+    if (itemCount) parts.push(`${subject}${itemCount}`);
+    return parts.join('；') || '素材限制随条件变化';
+  }
+  if (item.effect === 'no_selectable_values') {
+    if (target === 'ratio' && constraintHasCondition(item, 'resource.image.frame')) {
+      return `首尾帧模式不能手选比例；比例由输入图片决定，勿传 ${flag || localizedParamKey(target)}。`;
+    }
+    if (target === 'ratio') return `${flag || localizedParamKey(target)} 由素材决定，创建命令里不要再传。`;
+    return `${flag || localizedParamKey(target)} 触发后没有可选值，创建命令里不要再传。`;
+  }
+  if (Array.isArray(item.allowValues) && item.allowValues.length) {
+    if (target === 'ratio' && constraintHasCondition(item, 'generatedMode', 'multi_param')) {
+      return `比例只能选：${item.allowValues.join('、')}`;
+    }
+    return `只能选择：${item.allowValues.join('、')}`;
+  }
+  return item.effect;
+}
+
+function localizedList(values = [], mapper = (value) => value) {
+  if (!Array.isArray(values) || !values.length) return '';
+  return values.map(mapper).filter(Boolean).join('、');
+}
+
+function pushReadableRecord(lines, record = {}, fields = [], options = {}) {
+  const rows = fields
+    .map(([label, value]) => [label, value])
+    .filter(([, value]) => value !== undefined && value !== null && value !== '');
+  if (!rows.length) return;
+  const labelWidth = Math.max(...rows.map(([label]) => displayWidth(label)));
+  const indent = options.indent || '     ';
+  for (const [label, value] of rows) {
+    lines.push(`${indent}${padDisplay(label, labelWidth)}  ${prettyValue(value)}`);
+  }
+}
+
+function formatPrettyModelList(commandName, data = {}, context = {}) {
+  const normalized = normalizeOutputData(commandName, data);
+  const rows = Array.isArray(normalized.models) ? normalized.models : [];
+  const taskKind = commandName === 'model video-models' ? 'video' : 'image';
+  const limit = listLimitFor(commandName, context, rows);
+  const visibleRows = rows.slice(0, Number.isFinite(limit) ? limit : rows.length);
+  const lines = [prettyTitle(commandName, 'model_list', normalized), ''];
+  sectionTitle(lines, `模型（${rows.length}）`);
+  if (!visibleRows.length) {
+    lines.push(`  ${mutedText('无匹配模型')}`);
+  } else {
+    const tableRows = visibleRows.map((row, index) => ({
+      index: index + 1,
+      displayName: row.displayName,
+      note: row.modelDesc && row.modelDesc !== row.displayName ? row.modelDesc : row.provider,
+      modelGroupCode: row.modelGroupCode,
+      inputModesText: localizedList(row.inputModes, (item) => localizedInputMode(item, taskKind)),
+      paramsText: localizedList(row.params, localizedParamKey),
+      resourceText: localizedList(row.resourceParams, localizedResourceParam),
+      queue: row.taskQueueNum ?? '',
+      successRateText: formatPercent(row.successRate),
+    }));
+    lines.push(...renderPrettyTable(tableRows, [
+      column('#', 'index', { minWidth: 1, maxWidth: 2, always: true }),
+      column('模型', 'displayName', { minWidth: 10, maxWidth: 18, always: true }),
+      column('来源/备注', 'note', { minWidth: 10, maxWidth: 20 }),
+      column('模型组编码', 'modelGroupCode', { minWidth: 24, maxWidth: 36, always: true }),
+      column('支持生成', 'inputModesText', { minWidth: 12, maxWidth: 22 }),
+      column('可调参数', 'paramsText', { minWidth: 12, maxWidth: 22 }),
+      column('素材能力', 'resourceText', { minWidth: 8, maxWidth: 16 }),
+      column('排队数', 'queue', { minWidth: 4, maxWidth: 6 }),
+      column('成功率', 'successRateText', { minWidth: 4, maxWidth: 8 }),
+    ]));
+  }
+  if (rows.length > visibleRows.length) {
+    lines.push(`  ${mutedText(`还有 ${rows.length - visibleRows.length} 个模型未展示；运行 ${context.moreCommand || `${commandPrefix()} ${commandName} --all`} 查看全部。`)}`);
+  }
+  renderNextActions(lines, collectPrettyActions(commandName, normalized, context), '先查看候选模型参数和素材约束，再推荐或进入 fee/dry-run。');
+  return `${lines.join('\n')}\n`;
+}
+
+function renderModelParams(lines, params = []) {
+  const rows = Array.isArray(params) ? params : [];
+  sectionTitle(lines, `参数（${rows.length}）`);
+  if (!rows.length) {
+    lines.push(`  ${mutedText('无可调参数')}`);
+    return;
+  }
+  const tableRows = rows.map((param) => ({
+    name: param.label || param.name || localizedParamKey(param.key),
+    flag: cliFlagForParam(param.key),
+    type: localizedParamType(param.valueType || param.type),
+    values: Array.isArray(param.values) ? param.values.join('、') : '',
+    defaultValue: param.defaultValue,
+    required: param.required === undefined ? '' : prettyBoolean(param.required),
+    limit: param.maxLength ? `最长 ${param.maxLength} 字符` : '',
+  }));
+  lines.push(...renderPrettyTable(tableRows, [
+    column('参数', 'name', { minWidth: 8, maxWidth: 18, always: true }),
+    column('CLI', 'flag', { minWidth: 8, maxWidth: 16 }),
+    column('类型', 'type', { maxWidth: 10 }),
+    column('可选值', 'values', { minWidth: 12, maxWidth: 36 }),
+    column('默认', 'defaultValue', { maxWidth: 12 }),
+    column('必填', 'required', { maxWidth: 6 }),
+    column('限制', 'limit', { maxWidth: 16 }),
+  ]));
+}
+
+function renderModelResources(lines, resources = [], taskKind = '') {
+  const rows = Array.isArray(resources) ? resources : [];
+  sectionTitle(lines, `素材约束（${rows.length}）`);
+  if (!rows.length) {
+    lines.push(`  ${mutedText('不需要素材')}`);
+    return;
+  }
+  const tableRows = rows.map((item, index) => ({
+    index: index + 1,
+    purpose: localizedResourcePurpose(item, taskKind),
+    media: localizedMedia(item.mediaType),
+    input: localizedInputShapes(item.valueShapes || item.sources),
+    formats: localizedFormats(item),
+    count: localizedFileCount(item),
+    limits: [
+      item.maxSizeKB != null ? `单文件最多 ${formatKb(item.maxSizeKB)}` : '',
+      localizedDurationRange(item) ? `单个素材 ${localizedDurationRange(item)}` : '',
+      localizedTotalDuration(item) ? `总时长 ${localizedTotalDuration(item)}` : '',
+      localizedItemCount(item) ? `条目 ${localizedItemCount(item)}` : '',
+      localizedWebpPolicy(item),
+      item.supportLastFrameOnly === undefined ? '' : `仅尾帧：${prettyBoolean(item.supportLastFrameOnly)}`,
+    ].filter(Boolean).join('；'),
+  }));
+  lines.push(...renderPrettyTable(tableRows, [
+    column('#', 'index', { minWidth: 1, maxWidth: 2, always: true }),
+    column('用途', 'purpose', { minWidth: 14, maxWidth: 24, always: true }),
+    column('媒体', 'media', { maxWidth: 6, always: true }),
+    column('输入方式', 'input', { minWidth: 16, maxWidth: 40 }),
+    column('文件格式', 'formats', { minWidth: 10, maxWidth: 28 }),
+    column('数量', 'count', { maxWidth: 10 }),
+    column('其他限制', 'limits', { minWidth: 12, maxWidth: 30 }),
+  ]));
+}
+
+function renderModelConstraints(lines, constraints = []) {
+  const rows = Array.isArray(constraints) ? constraints : [];
+  sectionTitle(lines, `联动约束（${rows.length}）`);
+  if (!rows.length) {
+    lines.push(`  ${mutedText('无联动约束')}`);
+    return;
+  }
+  const tableRows = rows.map((item, index) => ({
+    index: index + 1,
+    target: localizedResourceTarget(item.target, item.limits) || localizedParamKey(item.target || item.targetConfigCode || '约束'),
+    condition: localizedConditions(item.conditions),
+    result: localizedConstraintResult(item),
+    note: item.name,
+  }));
+  lines.push(...renderPrettyTable(tableRows, [
+    column('#', 'index', { minWidth: 1, maxWidth: 2, always: true }),
+    column('影响参数', 'target', { minWidth: 8, maxWidth: 14, always: true }),
+    column('条件', 'condition', { minWidth: 16, maxWidth: 28 }),
+    column('结果', 'result', { minWidth: 18, maxWidth: 42, always: true }),
+    column('说明', 'note', { maxWidth: 24 }),
+  ]));
+}
+
+function listLimitFor(commandName, context, rows) {
+  if (context.listLimit === Number.POSITIVE_INFINITY) return rows.length;
+  if (Number.isFinite(context.listLimit)) return Math.max(0, context.listLimit);
+  if (commandName === 'schema') return Number.POSITIVE_INFINITY;
+  return Number.POSITIVE_INFINITY;
+}
+
+function collectListKeys(normalized, primaryKey) {
+  const keys = [];
+  if (primaryKey && Array.isArray(normalized?.[primaryKey])) keys.push(primaryKey);
+  for (const [key, value] of Object.entries(normalized || {})) {
+    if (keys.includes(key)) continue;
+    if (['resultUrls', 'originUrls'].includes(key)) continue;
+    if (Array.isArray(value)) keys.push(key);
+  }
+  return keys;
+}
+
+function collectPrettyActions(commandName, normalized, context = {}) {
+  const actions = [];
+  const add = (label, value) => {
+    if (value === undefined || value === null || value === '') return;
+    actions.push({ label, value: rewriteCommandPrefix(value) });
+  };
+  if (normalized?.nextCommand) add('继续查询', normalized.nextCommand);
+  if (normalized?.nextRefSubject) add('主体引用', normalized.nextRefSubject);
+  if (normalized?.nextVoiceArg) add('音色参数', normalized.nextVoiceArg);
+  if (normalized?.dryRun && context.confirmCommand) add('确认执行', context.confirmCommand);
+  if (normalized?.dryRun && !context.confirmCommand && context.executeCommand) add('正式执行', context.executeCommand);
+  const modelNext = modelListNextCommand(commandName);
+  if (modelNext) add(commandName === 'model asset-review-models' ? '查询素材组' : '查看参数', modelNext);
+  const waitNext = statusNextCommand(commandName, normalized);
+  if (waitNext) add('继续等待', waitNext);
+  const subtitleNext = subtitleRemoveNextCommand(commandName, normalized);
+  if (subtitleNext) add('去字幕预览', subtitleNext);
+  if (context.moreCommand) add('显示更多', context.moreCommand);
+  return actions;
+}
+
+function renderNextActions(lines, actions = [], hint = null) {
+  if (!actions.length && !hint) return;
+  sectionTitle(lines, '下一步');
+  const labelWidth = actions.length ? Math.max(...actions.map((item) => displayWidth(item.label))) : 0;
+  for (const item of actions) {
+    lines.push(`  ${labelText(padDisplay(item.label, labelWidth))}  ${commandText(prettyValue(item.value))}`);
+  }
+  if (hint) lines.push(`  ${labelText(padDisplay('提示', labelWidth || 2))}  ${mutedText(hint)}`);
+}
+
+function renderUrlLists(lines, normalized) {
+  renderScalarList(lines, '结果链接', normalized?.resultUrls, 6);
+  renderScalarList(lines, '原始素材', normalized?.originUrls, 6);
+}
+
+function formatPrettySchema(data = {}, context = {}) {
+  const lines = [prettyTitle('schema', 'command_schema', data), ''];
+  const isBrief = data.kind === 'agent_brief';
+  renderDetails(lines, '摘要', {
+    schemaVersion: data.schemaVersion,
+    kind: data.kind,
+    cli: data.cli?.name,
+    version: data.cli?.version,
+    commandPrefix: data.cli?.commandPrefix,
+    domainFilter: data.filters?.domain,
+    commandFilter: data.filters?.command,
+    commandCount: data.commandCount ?? (Array.isArray(data.commands) ? data.commands.length : undefined),
+  }, ['schemaVersion', 'kind', 'cli', 'version', 'commandPrefix', 'domainFilter', 'commandFilter', 'commandCount']);
+  renderArraySection(lines, '命令领域', data.domains, 'domains');
+  if (!isBrief) renderArraySection(lines, '命令', data.commands, 'commands');
+  renderNextActions(lines, [
+    ...(isBrief ? [
+      { label: '精确 Schema', value: `${commandPrefix()} schema --domain <domain> --command <command> -f json` },
+      { label: '完整 Schema', value: `${commandPrefix()} schema -f json` },
+    ] : [
+      { label: 'Agent Brief', value: `${commandPrefix()} schema --brief -f json` },
+      { label: 'Schema JSON', value: `${commandPrefix()} schema -f json` },
+    ]),
+    ...(context.jsonCommand ? [{ label: '当前筛选 JSON', value: context.jsonCommand }] : []),
+  ], isBrief ? '先读 brief 建立能力地图；执行具体命令前按需读取精确 schema。' : undefined);
+  return `${lines.join('\n')}\n`;
+}
+
+function formatPrettyEnvironment(data = {}, context = {}) {
+  const lines = [prettyTitle('doctor', 'environment_report', data), ''];
+  renderDetails(lines, '摘要', {
+    doctorStatus: data.doctorStatus,
+    verify: data.verify,
+    nodeVersion: data.runtime?.nodeVersion,
+    platform: data.runtime?.platform,
+    arch: data.runtime?.arch,
+    apiOrigin: data.origins?.apiOrigin,
+    authState: data.auth?.loginState,
+    authType: data.auth?.authType,
+    accessKey: data.auth?.accessKey,
+    currentProjectGroupNo: data.projectGroup?.projectGroupNo,
+    currentProjectGroupName: data.projectGroup?.projectGroupName,
+  }, ['doctorStatus', 'verify', 'nodeVersion', 'platform', 'arch', 'apiOrigin', 'authState', 'authType', 'accessKey', 'currentProjectGroupNo', 'currentProjectGroupName']);
+  renderArraySection(lines, '检查结果', data.checks, 'checks');
+  renderNextActions(lines, collectPrettyActions('doctor', data, context));
+  return `${lines.join('\n')}\n`;
+}
+
+function formatPrettyModelOptions(data = {}, context = {}) {
+  const lines = [prettyTitle('model options', 'model_options', data), ''];
+  renderDetails(lines, '摘要', {
+    modelGroupCode: data.modelGroupCode,
+    taskKind: localizedTaskKind(data.taskKind),
+    displayName: data.model?.displayName,
+    modelDesc: data.model?.modelDesc,
+  }, ['modelGroupCode', 'displayName', 'taskKind', 'modelDesc']);
+  renderModelParams(lines, data.params);
+  renderModelResources(lines, data.resources, data.taskKind);
+  renderModelConstraints(lines, data.constraints);
+  renderNextActions(lines, [
+    { label: '生成创建写法', value: `${commandPrefix()} model create-spec --model-group-code ${data.modelGroupCode || '<modelGroupCode>'}` },
+    ...(context.textCommand ? [{ label: 'Agent 读取', value: context.textCommand }] : []),
+    ...(context.jsonCommand ? [{ label: '完整 JSON', value: context.jsonCommand }] : []),
+  ]);
+  return `${lines.join('\n')}\n`;
+}
+
+function formatPrettyModelCreateSpec(data = {}, context = {}) {
+  const taskKind = data.taskKind;
+  const lines = [prettyTitle('model create-spec', 'model_create_spec', data), ''];
+  renderDetails(lines, '摘要', {
+    modelGroupCode: data.modelGroupCode,
+    taskKind: localizedTaskKind(data.taskKind),
+    createCommand: data.createCommand,
+    feeCommand: data.feeCommand,
+    statusCommandTaskType: data.statusCommandTaskType,
+    inputSummary: localizedCreateSpecSummary(data.inputRequirement?.summary),
+    acceptedModes: localizedModeList(data.inputRequirement?.acceptedModes, taskKind),
+  }, ['modelGroupCode', 'taskKind', 'createCommand', 'feeCommand', 'statusCommandTaskType', 'inputSummary', 'acceptedModes']);
+  renderArraySection(lines, '支持意图', data.supportedIntents, [
+    column('输入方式', (row) => localizedIntentMode(row.mode, taskKind), { minWidth: 12, maxWidth: 22 }),
+    column('意图', (row) => localizedIntentText(row.intent, row.mode, taskKind), { minWidth: 10, maxWidth: 24 }),
+    column('必需写法', (row) => commandArgLines(row.requiredArgs), { minWidth: 22, maxWidth: 62 }),
+    column('素材用途', (row) => localizedList(row.resourceUsages, localizedUsage), { minWidth: 10, maxWidth: 24 }),
+    column('Prompt 绑定', (row) => localizedPromptBinding(row.promptBinding), { maxWidth: 14 }),
+  ]);
+  renderScalarList(lines, '示例', (data.examples || []).map((example) => modelCreateExampleWithCode(example, data.modelGroupCode)).map((item) => item.replaceAll('--model-group-code <code>', `--model-group-code ${data.modelGroupCode || '<code>'}`)), 8);
+  const actions = [];
+  if (data.optionsCommand) actions.push({ label: '查看参数', value: `${commandPrefix()} ${data.optionsCommand}` });
+  const feeNext = modelFeeNextCommand(data);
+  if (feeNext) actions.push({ label: '费用预估', value: feeNext });
+  if (data.examples?.[0]) actions.push({ label: 'Dry-run', value: modelCreateExampleWithCode(data.examples[0], data.modelGroupCode) });
+  if (context.textCommand) actions.push({ label: 'Agent 读取', value: context.textCommand });
+  if (context.jsonCommand) actions.push({ label: '完整 JSON', value: context.jsonCommand });
+  renderNextActions(lines, actions);
+  return `${lines.join('\n')}\n`;
+}
+
+function formatPrettyModelInputGuide(data = {}, context = {}) {
+  const lines = [prettyTitle('model input-guide', 'model_input_guide', data), ''];
+  renderDetails(lines, '摘要', {
+    schemaVersion: data.schemaVersion,
+    commonFieldCount: Array.isArray(data.commonFields) ? data.commonFields.length : undefined,
+    resourceFieldCount: Array.isArray(data.resourceFields) ? data.resourceFields.length : undefined,
+    resourceRuleCount: Array.isArray(data.resourceRules) ? data.resourceRules.length : undefined,
+  }, ['schemaVersion', 'commonFieldCount', 'resourceFieldCount', 'resourceRuleCount']);
+  const guideColumns = [
+    column('字段', 'field', { maxWidth: 32 }),
+    column('可选值', localizedGuideValues, { maxWidth: 46 }),
+    column('说明', 'description', { maxWidth: 70 }),
+  ];
+  renderArraySection(lines, '通用字段', data.commonFields, guideColumns);
+  renderArraySection(lines, '资源字段', data.resourceFields, guideColumns);
+  renderScalarList(lines, '资源规则', data.resourceRules, 12);
+  renderScalarList(lines, 'Reference Key 指南', data.referenceKeyGuide, 12);
+  renderNextActions(lines, [
+    { label: '生图模型', value: `${commandPrefix()} model image-models --model <keyword>` },
+    { label: '生视频模型', value: `${commandPrefix()} model video-models --model <keyword>` },
+    { label: '模型参数', value: `${commandPrefix()} model options --model-group-code <modelGroupCode>` },
+    ...(context.textCommand ? [{ label: 'Agent 读取', value: context.textCommand }] : []),
+    ...(context.jsonCommand ? [{ label: '完整 JSON', value: context.jsonCommand }] : []),
+  ]);
+  return `${lines.join('\n')}\n`;
+}
+
+function formatPrettyGeneric(commandName, data, context = {}) {
+  const normalized = normalizeOutputData(commandName, data);
+  const kind = outputKindForCommand(commandName, context);
+  if (!isPlainObject(normalized)) {
+    const lines = [prettyTitle(commandName, kind, data), ''];
+    renderDetails(lines, '结果', { value: normalized }, ['value']);
+    return `${lines.join('\n')}\n`;
+  }
+  const profile = PRETTY_KIND_PROFILES[kind] || PRETTY_KIND_PROFILES.generic;
+  const lines = [prettyTitle(commandName, kind, normalized), ''];
+  const listKeys = collectListKeys(normalized, profile.listKey);
+  const excluded = new Set(['raw', ...listKeys, 'resultUrls', 'originUrls', 'waited']);
+  const summaryFields = normalized.dryRun
+    ? (DRY_RUN_FIELDS_BY_COMMAND[commandName] || ['dryRun', 'action', ...(profile.fields || [])])
+    : (profile.fields || []);
+  renderDetails(lines, normalized.dryRun ? '预览摘要' : '摘要', normalized, summaryFields, [...excluded]);
+  if (normalized.waited) {
+    renderDetails(lines, '等待结果', normalized.waited, DETAIL_FIELDS_BY_KIND.task_status || []);
+  }
+  for (const key of listKeys) {
+    const rows = normalized[key];
+    if (!Array.isArray(rows)) continue;
+    const limit = listLimitFor(commandName, context, rows);
+    renderArraySection(lines, namedListTitle(key), rows, key, limit);
+  }
+  renderUrlLists(lines, normalized);
+  renderNextActions(lines, collectPrettyActions(commandName, normalized, context), modelListAgentHint(commandName));
+  return `${lines.join('\n')}\n`;
+}
+
+export function formatPrettyOutput(commandName, data, context = {}) {
+  if (commandName === 'schema') return formatPrettySchema(data, context);
+  if (commandName === 'doctor') return formatPrettyEnvironment(data, context);
+  if (commandName === 'model image-models' || commandName === 'model video-models') return formatPrettyModelList(commandName, data, context);
+  if (commandName === 'model options') return formatPrettyModelOptions(data, context);
+  if (commandName === 'model create-spec') return formatPrettyModelCreateSpec(data, context);
+  if (commandName === 'model input-guide') return formatPrettyModelInputGuide(data, context);
+  return formatPrettyGeneric(commandName, data, context);
+}
+
+function yamlScalar(value) {
+  if (value === null) return 'null';
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  const text = String(value ?? '');
+  return JSON.stringify(text);
+}
+
+function formatYamlValue(value, indent = 0) {
+  const pad = ' '.repeat(indent);
+  if (Array.isArray(value)) {
+    if (!value.length) return '[]';
+    return value.map((item) => {
+      if (isPlainObject(item) || Array.isArray(item)) {
+        const rendered = formatYamlValue(item, indent + 2);
+        return `${pad}- ${rendered.includes('\n') ? `\n${rendered}` : rendered}`;
+      }
+      return `${pad}- ${yamlScalar(item)}`;
+    }).join('\n');
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined);
+    if (!entries.length) return '{}';
+    return entries.map(([key, item]) => {
+      if (isPlainObject(item) || Array.isArray(item)) {
+        return `${pad}${key}:\n${formatYamlValue(item, indent + 2)}`;
+      }
+      return `${pad}${key}: ${yamlScalar(item)}`;
+    }).join('\n');
+  }
+  return yamlScalar(value);
+}
+
+export function formatYamlEnvelope(payload) {
+  return `${formatYamlValue(rewriteNested(payload), 0)}\n`;
+}
+
+function csvEscape(value) {
+  const text = String(prettyValue(value));
+  return /[",\n\r]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+
+function csvColumnsForRows(rows = []) {
+  const cols = inferTableColumns(rows);
+  return cols.map((col) => ({
+    header: col.header,
+    key: col.key,
+    value: col.value,
+  }));
+}
+
+export function formatCsvOutput(commandName, data, context = {}) {
+  const normalized = normalizeJsonData(commandName, data);
+  const kind = outputKindForCommand(commandName, context);
+  const primaryKey = LIST_KEY_BY_KIND[kind];
+  const list = primaryKey && Array.isArray(normalized?.[primaryKey])
+    ? { key: primaryKey, rows: normalized[primaryKey] }
+    : firstList(normalized);
+  const rows = list?.rows?.length ? list.rows : (isPlainObject(normalized) ? [normalized] : [{ value: normalized }]);
+  const columns = TABLE_COLUMNS[list?.key] || csvColumnsForRows(rows);
+  const headers = columns.map((col) => col.header);
+  const lines = [headers.map(csvEscape).join(',')];
+  for (const row of rows) {
+    lines.push(columns.map((col) => csvEscape(resolveColumnValue(row, col))).join(','));
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+export function formatPrettyError(error) {
+  const lines = [errorTitleText('命令失败'), ''];
+  renderDetails(lines, '错误', {
+    type: error.type || 'error',
+    message: error.message || String(error),
+    hint: error.hint ? rewriteCommandPrefix(error.hint) : undefined,
+  }, ['type', 'message', 'hint']);
+  if (isPlainObject(error.details)) {
+    const payload = isPlainObject(error.details.payload) ? error.details.payload : {};
+    renderDetails(lines, '详情', compactRecord({
+      status: error.details.status ?? payload.status,
+      code: error.details.code ?? payload.code,
+      msg: error.details.msg ?? payload.msg ?? payload.message,
+      traceId: error.details.traceId ?? payload.traceId,
+      causeCode: error.details.causeCode,
+      unknownOptions: Array.isArray(error.details.unknownOptions) ? error.details.unknownOptions.join(', ') : undefined,
+    }), ['status', 'code', 'msg', 'traceId', 'causeCode', 'unknownOptions']);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
 export function formatTextOutput(commandName, data, context = {}) {
   if (commandName === 'model options') return formatModelOptionsOutput(data);
   if (commandName === 'model create-spec') return formatModelCreateSpecOutput(data);
@@ -1206,6 +3135,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);