tripo-cli 0.7.3 → 0.8.1

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## 0.8.1
+
+- Add `tripo models`: lists the model ids each capability accepts (3D generation, text-to-image, image-to-image, texture, rig, segment, decimate) with defaults and CLI aliases. It reads the local whitelist, makes no API call and is excluded from analytics like `docs`/`config`. `--json` prints one JSON line.
+
+## 0.8.0
+
+- Preflight every deterministic `make` chain request before uploads or generation. Normal runs and dry runs use the same validation; direct `executeMake` validates before balance/generation calls. Runtime source-dependent checks remain in place.
+- Normalize `H3.1`, `P1.0`, `P2.0` (also `P2.0 Preview`) and legacy `H3.0` / `H2.5` display aliases case-insensitively, alongside existing `tripo-*` names. Reject unknown 3D models; require finite integer generation/convert/decimate face limits; enforce rig version/body/spec and texture-quality compatibility.
+- Validate text-to-image and image-to-image model whitelists, quality, background/format linkage and documented size constraints. Reject `seedream_v4` on image editing and retired `chat_image_1` on both endpoints. Keep `chat_image_1.5` active (announced retirement: 2026-12-01). Never silently switch models or resubmit.
+- Image editing validates deterministic parameters before local uploads. Unknown extra parameter keys remain passthrough; they are not claimed as validated.
+- Derive plan-card details and deliverables from normalized requests, include adjustment warnings, and retain scenario tips only when their assumptions still hold. Explicit model/parameter overrides no longer inherit misleading P2, quad-output or HD-cost claims. P2 is no longer labelled Preview in plan cards, scenario notes or bundled docs. Remove fixed-credit quotes from retopology model-selection warnings.
+- Estimate the generation step locally from official list prices (identical on ov and cn): H3.1 10–40 credits for text and 20–50 for image/multiview by texture tier, plus `geometry_quality=detailed` +20, `quad` +5, `smart_low_poly` +10, `generate_parts` +20; P2 100–130 for every input. Plan cards show it (× `-n` candidates) and dry-run JSON adds `generation_credits_estimate`. P1, legacy models, imports and chain steps stay "not estimated" (`null`), never zero. P2 quad notes no longer claim a higher price tier.
+- `texture=false` without an explicit `pbr` now also sends `pbr=false` (with a warning): `pbr` defaults to true server-side and forces texturing, so the bare-geometry request and its estimate stay consistent.
+- Treat H3.1 as the official default model (`official default → v3.1`). Face budgets below P2's minimum (48) now select H3.1, like budgets above P2's maximum. Narrow real-time prompt hints: board/card/tabletop games, gaming PCs, consoles and animation styles (`animation-style`, `动画风格`, `动画片`) no longer select P2.
+- Complete static preflight on standalone image/multiview-to-model and headless multi-candidate chains before local uploads. Reject deterministic rig/preset-family conflicts before generation, including direct executeMake/runChain callers; do not guess a standalone retarget source's rig version.
+- Validate the effective 3D text prompt's 1024-character limit and image-editing reference limits (Seedream 4, Banana 10, Chat Image 16) before submission/upload.
+- Do not inject a biped-only spec into the built-in anim scenario; a quadruped rig-check recommendation can proceed. Explicit unsupported specs are still rejected locally rather than silently dropped.
+- Handle explicit Chinese/English dense-geometry negation per mention, while retaining separate positive requirements. This is a lexical safeguard, not full language understanding; use an explicit model for ambiguous intent.
+- Preserve existing P-series unsupported-field removal with warnings; normalized payloads, not the original unsupported combination, are what local validation approves.
+- Bundled skill: H3.1 is described as the official default; presets outrank prompt hints and list their models; agents relay the P2 estimate and get confirmation before running it, and ask before `tripo redo` (a new paid task with no plan card or confirmation). P1 is no longer described as fast. The `batch` docs add a Cost section: every job is a full `make` with no plan card or confirmation, so agents estimate the run from a dry run per preset and get confirmation first.
+- All CLI output (logs, plan cards, error messages and suggestions, interactive prompts, help text) is English only. The `language` config key and `LANG`/`LC_ALL`-based switching are removed; Chinese prompts are still understood.
+- `batch run` never resubmits a job once a paid task may exist. It retries only when the failed attempt left no task behind (it failed before submission, or its only task failed and was refunded). Otherwise the job stops as `needs_attention` with `tasks`, `error` and `suggestion` in the state file, is skipped on re-run, and counts toward exit 6 (the summary adds `needs_attention`).
+- Strict pipes: when stdin is not a terminal, process commands without an explicit input never fall back to `@last`. Empty stdin or no `task_id` exits 2; an upstream error JSON exits with the upstream's code; nothing is submitted in either case.
+- A task that succeeds but whose artifact download fails now exits 7 instead of reporting success; the error JSON carries `task_id` and suggests `tripo task get <id> --download`. `make -n` keeps such candidates with `download_error` (exit 7). Error JSON for failed or timed-out tasks also carries `task_id`.
+- `task watch --json` writes progress to stderr and stdout carries only the final JSON line; the NDJSON progress events on stdout are removed. Docs now state the contract as "every result command prints exactly one JSON line" (`docs`/`completion` print text, `mcp` speaks JSON-RPC).
+- The bundled `SKILL.md` starts with YAML frontmatter (`name: tripo-cli`, `description`) so skill loaders can discover it.
+- Fix the color 3D-print recipe: `--for print -p texture=true --then convert:format=OBJ,export_vertex_colors=true`. API 3MF output is single color, so build a multi-color 3MF in the slicer; the print preset no longer lists "3MF (colored)" as a deliverable.
+- `--for ar-web` generates P2 with `face_limit=20000` instead of a follow-up decimate step (saves the 30-credit decimate) and downloads the generated GLB as well as the USDZ. The result adds `source_output_dir` / `source_model_file`, and the plan card lists both deliverables. `--then` replaces the preset chain and keeps the final-step-only download.
+- Update bundled skill and capability documentation and add unit/mock CLI preflight regressions. No real generation, billing or credentials are required by these tests.
+
+Known precision boundary: official Seedream size documentation gives rounded MP ranges. This release validates syntax/tiers/aspect ratio, not an invented exact pixel-count cutoff; Banana Pro undocumented pixel limits and arbitrary passthrough fields remain server-validated. Mesh edit stays experimental and disabled by default.

package/README.md

@@ -1,5 +1,7 @@
 # tripo-cli
 
+0.8.0 validates all statically known `make` chain requests before uploads or generation, including normal runs, dry runs and direct `executeMake` calls. `H3.1` / `P1.0` / `P2.0` (plus legacy `H3.0` / `H2.5`, case-insensitive) normalize to dated wire IDs and share the same limits as `tripo-*` aliases; unknown 3D/image models are rejected. Image generation validates endpoint-specific models, quality, background, output format and documented size rules before image-edit uploads. `chat_image_1` is retired and rejected; `chat_image_1.5` remains supported until its announced 2026-12-01 retirement. Plans show scenario notes and the official list-price estimate for the generation step; P1, legacy models and chain steps are marked **not estimated**, never an invented zero-credit quote. See [CHANGELOG](CHANGELOG.md). Unknown extra parameter keys remain passthrough, not a guarantee of server validity.
+
 Turn a sentence or an image into an engine-ready 3D asset from your terminal, powered by the [Tripo](https://www.tripo3d.ai) V3 API.
 
 ```bash
@@ -20,9 +22,9 @@ Works with both Tripo regions from the same install — international (`openapi.
 ## Why this CLI
 
 - **One magic command.** `tripo make <anything>` detects what you gave it — prompt text, an image, 2–4 view images, a model file, a URL, a task id, or `@last` — picks the right endpoint, model, and parameters, then waits and downloads the artifacts. No file_token, no polling loops.
-- **A 3D domain brain, not a thin API wrapper.** Model choice is a fixed rule (low-poly intent or face budget ≤ 20000 → `tripo-p1`, everything else → `tripo-v3.1`; opt into the P-series **Preview** with `--model tripo-p2` for quad low-poly). Those are CLI aliases — the wire value the API receives is `P1-20260311` / `v3.1-20260211` / `P2-20260801` (full alias ↔ wire ↔ status table: `tripo docs --topic commands/generate`; official [Models & Versions](https://developers.tripo3d.ai/en/docs/models-and-versions) and [P Series](https://developers.tripo3d.ai/en/models/p1) pages). P-series illegal parameters are stripped locally, quad + GLB is rejected before it costs you credits, and 7 scenario presets (`--for game-mobile|game-pc|film|print|ar-web|anim|toy`) encode sane parameters + processing chains + delivery formats.
+- **A 3D domain brain, not a thin API wrapper.** Explicit `--model` always wins. `tripo-v3.1` (H3.1) is the official default flagship model, and dense geometry, `smart_low_poly=true`, `generate_parts=true`, any explicit `geometry_quality`, or a face budget outside P2's range select it first; a `--for` preset comes next and outranks prompt hints. Otherwise real-time, game, editable, low-poly, voxel, quad, or a face budget within P2's range select `tripo-p2`. `tripo-p1` is an explicit lower-cost option. P2 costs 100–130 credits per generation versus 10–50 for H3.1 before add-ons; the plan card shows the estimate before you run. These are CLI aliases — the wire value the API receives is `P1-20260311` / `v3.1-20260211` / `P2-20260801` (full alias ↔ wire ↔ status table: `tripo docs --topic commands/generate`; official [Models & Versions](https://developers.tripo3d.ai/en/docs/models-and-versions) and [P Series](https://developers.tripo3d.ai/en/models/p1) pages). P-series illegal parameters are stripped locally, quad + GLB is rejected before it costs you credits, and 7 scenario presets (`--for game-mobile|game-pc|film|print|ar-web|anim|toy`) encode sane parameters + processing chains + delivery formats.
 - **You see the plan before you pay.** `tripo make` prints a plan card — one numbered line per API call (endpoint, what it does, its arguments) — and asks before submitting; afterwards it reports the total credits **and** a per-task breakdown. `--yes` (automatic when headless) skips the question but keeps the card in the log.
-- **Agent-native.** Non-TTY runs are automatically headless (`--json --yes --no-open`), stdout carries exactly one JSON line per command, progress goes to stderr, exit codes are stable, and NDJSON pipes compose: `tripo make cat.png | tripo model texture | tripo anim rig`. An LLM-facing skill package ships inside the npm package (`tripo docs --llm`).
+- **Agent-native.** Non-TTY runs are automatically headless (`--json --yes --no-open`), every result command prints exactly one JSON line on stdout (`docs`/`completion` print text, `mcp` speaks JSON-RPC), progress goes to stderr, exit codes are stable, and JSON pipes compose: `tripo make cat.png | tripo model texture | tripo anim rig`. An LLM-facing skill package ships inside the npm package (`tripo docs --llm`).
 
 ## Commands
 
@@ -34,9 +36,10 @@ Works with both Tripo regions from the same install — international (`openapi.
 | `tripo redo [task]` | re-run with a fresh seed |
 | `tripo login / logout / whoami / use` | device flow: browser approves, key arrives automatically (paste fallback); stored 0600 in `~/.tripo/config.json`; `use` switches accounts |
 | `tripo topup / balance / usage` | open the billing page + detect the credits arriving; check spend |
+| `tripo models` | list the model ids each capability accepts, with defaults and aliases (local whitelist, no API call) |
 | `tripo generate <endpoint>` | deterministic access to all 8 generation endpoints |
 | `tripo model / anim / mesh <step>` | texture, convert, import, rig-check, rig, retarget, segment, complete, decimate, uv, smartsegment |
-| `tripo task get/list/watch` | query and stream task progress (NDJSON in `--json` mode) |
+| `tripo task get/list/watch` | query tasks and wait for them (progress on stderr) |
 | `tripo files upload` | upload a file, print the `file_token` |
 | `tripo batch run <manifest.yaml>` | bulk pipelines with concurrency, retries, and resume |
 | `tripo config / doctor` | settings (global + per-directory `.tripo/context.json`) and self-diagnosis |
@@ -65,10 +68,10 @@ Each profile carries its own key + region, so switching accounts switches region
 ## Scenario presets
 
 ```bash
-tripo make "sci-fi crate" --for game-mobile   # P1 low-poly → texture → FBX
+tripo make "sci-fi crate" --for game-mobile   # P2 editable topology → texture → FBX
 tripo make hero.png --for film                # v3.1, quad topology, 4K PBR → USDZ/OBJ
 tripo make "chess knight" --for print         # no textures, watertight → STL, flat bottom
-tripo make sofa.jpg --for ar-web              # decimate to mobile budget → GLB + USDZ
+tripo make sofa.jpg --for ar-web              # P2 capped at 20k faces → GLB + USDZ
 tripo make "orc warrior" --for anim           # rig-check gate → rig → FBX
 ```
 
@@ -91,8 +94,8 @@ tripo batch run assets.yaml --concurrency 2
 
 - `make`/`watch` are blocking: run them, wait for exit, read the single JSON line on stdout. Do not poll yourself.
 - The plan card on stderr lists every call before it runs; the final JSON carries `credits_consumed` (total for the run) plus `credits_breakdown` (per task) when a chain ran.
-- Exit codes: `0` ok · `2` usage · `3` auth · `4` insufficient credits · `5` content policy · `6` task failed (failed/cancelled tasks are auto-refunded; a `timeout` means it is still running) · `7` network (a failed submit is never resent — check `tripo balance` before re-running) · `8` not found · `9` rate limit.
-- `preview.png` in every output directory is your eyes: look at it, then decide to `tripo redo` or continue the chain.
+- Exit codes: `0` ok · `2` usage · `3` auth · `4` insufficient credits · `5` content policy · `6` task failed (failed/cancelled tasks are auto-refunded; a `timeout` means it is still running) · `7` network (a failed submit is never resent — check `tripo balance` before re-running; a task that succeeded but failed to download carries `task_id` in the error JSON — run `tripo task get <task_id> --download`, never re-make) · `8` not found · `9` rate limit.
+- `preview.png` in every output directory is your eyes: look at it, then continue the chain or ask the human before `tripo redo` (a new paid task with no plan card or confirmation).
 - Full behavior rules: `tripo docs --llm`, per-command docs via `tripo docs --topic commands/make`.
 
 ## Environment variables

package/dist/ai/experts.js

@@ -6,12 +6,11 @@
  * knowledge base (scenario ids, step names, parameter windows), and the
  * result is re-validated locally before anything is spent.
  */
-import { getLocale, t, tList } from '../i18n.js';
 import { availableSteps, parseThenExpression, validateChain } from '../knowledge/chains.js';
-import { CAPABILITY_DEFAULTS, chooseModel, detectLowPolyIntent } from '../knowledge/models.js';
+import { CAPABILITY_DEFAULTS, chooseModel, detectDenseGeometryIntent, detectLowPolyIntent, detectRealtimeIntent } from '../knowledge/models.js';
 import { getScenario, SCENARIOS } from '../knowledge/scenarios.js';
 import { chatJson } from './llm.js';
-const SCENARIO_TABLE = SCENARIOS.map((s) => `- ${s.id}: ${s.description.en} | model=${s.model} | chain=${s.chain.map((c) => c.step).join('→') || 'none'} | deliver=${s.deliverables.join('/')}`).join('\n');
+const SCENARIO_TABLE = SCENARIOS.map((s) => `- ${s.id}: ${s.description} | model=${s.model} | chain=${s.chain.map((c) => c.step).join('→') || 'none'} | deliver=${s.deliverables.join('/')}`).join('\n');
 const STEP_TABLE = availableSteps().map((s) => s.name).join(', ');
 const PRODUCER_SYSTEM = `You are the producer/router of the Tripo 3D generation CLI.
 Classify the user's request into exactly one scenario and extract a clean English 3D generation prompt.
@@ -23,30 +22,30 @@ Rules:
 - "prompt" must describe the object to generate (translate to English, keep it concrete, <= 200 chars).
 - Set "face_limit" only when the user states a face/polygon budget.
 - Set "needs_animation" true only when the user wants skeleton/animations.
-- If one critical piece of information is missing and materially changes the plan, set "question" (one short question in the user's language). Otherwise omit it.
+- If one critical piece of information is missing and materially changes the plan, set "question" (one short question in English). Otherwise omit it.
 Respond with JSON only: {"scenario","prompt","face_limit","needs_animation","question","notes"}`;
 const SPECIALIST_PROMPTS = {
-    'game-mobile': `You are a senior game technical artist (mobile). Budgets: 500–20000 faces, 1–2K textures, clean topology, FBX/GLB delivery. P1 model is used (no quad/parts/geometry_quality).`,
-    'game-pc': `You are a senior game technical artist (PC/console). PBR detailed textures, optional decimate for LODs (bake=true), FBX delivery with engine presets.`,
+    'game-mobile': `You are a senior game technical artist (mobile). Prefer P2 editable topology for 48–25000 quad or 48–50000 triangle faces, 1–2K textures, and FBX/GLB delivery. Call out P2's higher credit cost.`,
+    'game-pc': `You are a senior game technical artist (PC/console). Prefer P2 editable topology with detailed PBR textures, optional decimate for LODs (bake=true), and FBX delivery with engine presets. Use H only when dense geometry or H-only parameters are required. Call out P2's higher credit cost.`,
     film: `You are a film/offline-rendering artist. quad=true subdivision-friendly topology (FBX output), geometry_quality=detailed, texture_quality=detailed, 4K textures, USD/OBJ handoff via convert.`,
-    print: `You are a 3D-printing engineer. Geometry only (texture=false,pbr=false), watertight meshes, flatten_bottom for FDM, STL or colored 3MF via convert, real-world sizing via auto_size at generation or scale_factor at convert.`,
-    'ar-web': `You are a realtime AR/Web 3D engineer. Keep faces <= 20000 via decimate, 2K textures, deliver GLB + USDZ (iOS QuickLook).`,
-    anim: `You are a character animation TD. Chain: rig-check → rig (v3.0 rig, spec tripo|mixamo|actorcore|unity|unreal|vrm, biped only) → retarget (<=5 preset animations, billed per animation). Mixamo → spec=mixamo; Unity Humanoid → spec=unity; Unreal → spec=unreal.`,
-    toy: `You are a stylized collectible designer. P1 low-poly. STL via convert for physical prints.`,
+    print: `You are a 3D-printing engineer. Geometry only (texture=false,pbr=false), watertight meshes, flatten_bottom for FDM, STL via convert (API 3MF output is single color; for color prints set texture=true and convert to OBJ with export_vertex_colors=true), real-world sizing via auto_size at generation or scale_factor at convert.`,
+    'ar-web': `You are a realtime AR/Web 3D engineer. Prefer P2 editable topology, keep faces <= 20000 with face_limit at generation (no decimate step), use 2K textures, and deliver GLB + USDZ (iOS QuickLook). Call out P2's higher credit cost.`,
+    anim: `You are a character animation TD. Prefer P2 editable topology. Chain: rig-check → rig (v3.0 rig, spec tripo|mixamo|actorcore|unity|unreal|vrm, biped only) → retarget (<=5 preset animations, billed per animation). Mixamo → spec=mixamo; Unity Humanoid → spec=unity; Unreal → spec=unreal. Call out P2's higher credit cost.`,
+    toy: `You are a stylized collectible designer. Prefer P2 editable low-poly topology; use STL via convert for physical prints. Call out P2's higher credit cost.`,
 };
 function specialistSystem(scenarioId) {
     const persona = SPECIALIST_PROMPTS[scenarioId] ?? SPECIALIST_PROMPTS['game-mobile'];
     return `${persona}
 You fine-tune a Tripo generation plan. You may adjust generation params and the processing chain.
 Valid chain steps: ${STEP_TABLE}. Chain syntax: "step:key=value,step2" (e.g. "texture,rig,convert:format=FBX").
-Constraints: pbr=>texture; generate_parts excludes texture/pbr/quad; P1 face_limit 50-20000 and forbids quad/smart_low_poly/generate_parts/geometry_quality; retarget <= 5 animations.
-Respond with JSON only: {"params":{...},"chain":"...","notes":["short practical notes in ${getLocale() === 'zh' ? 'Chinese' : 'English'}"]}. Omit fields you don't want to change.`;
+Constraints: pbr=>texture; generate_parts excludes texture/pbr/quad; P2 face_limit is 48-50000 triangles or 48-25000 quads and forbids smart_low_poly/generate_parts/geometry_quality; retarget <= 5 animations.
+Respond with JSON only: {"params":{...},"chain":"...","notes":["short practical notes in English"]}. Omit fields you don't want to change.`;
 }
 /**
  * Run the expert pipeline. `askUser` is called when the producer needs one
  * clarification (interactive mode only); return undefined to skip.
  */
-export async function buildExpertPlan(request, askUser) {
+export async function buildExpertPlan(request, askUser, overrides = {}) {
     const messages = [
         { role: 'system', content: PRODUCER_SYSTEM },
         { role: 'user', content: request },
@@ -69,9 +68,12 @@ export async function buildExpertPlan(request, askUser) {
         },
     ]).catch(() => ({}));
     // Merge + re-validate everything the LLM produced.
-    const params = { ...scenario.genParams, ...(specialist.params ?? {}) };
-    if (producer.face_limit)
-        params.face_limit = producer.face_limit;
+    const params = {
+        ...scenario.genParams,
+        ...(specialist.params ?? {}),
+        ...(producer.face_limit === undefined ? {} : { face_limit: producer.face_limit }),
+        ...overrides,
+    };
     let chain = scenario.chain;
     if (specialist.chain) {
         try {
@@ -90,9 +92,13 @@ export async function buildExpertPlan(request, askUser) {
         ];
     }
     const choice = chooseModel({
-        explicit: scenario.model,
+        preferred: scenario.model,
         faceLimit: typeof params.face_limit === 'number' ? params.face_limit : undefined,
+        quad: params.quad === true,
         lowPoly: detectLowPolyIntent(request),
+        realtime: detectRealtimeIntent(request),
+        denseGeometry: detectDenseGeometryIntent(request),
+        params,
     });
     try {
         validateChain(chain, 'text_to_model');
@@ -104,11 +110,11 @@ export async function buildExpertPlan(request, askUser) {
         inputSummary: producer.prompt,
         scenario: scenario.id,
         model: choice.model,
-        modelReason: t({ zh: '制片人路由 + 场景预设', en: 'producer routing + scenario preset' }),
+        modelReason: 'producer routing + scenario preset',
         genParams: params,
         chain,
         deliverables: scenario.deliverables,
-        notes: tList(scenario.notes),
+        notes: scenario.notes,
         expertNotes: [...(producer.notes ?? []), ...(specialist.notes ?? [])],
     };
     return { card, scenarioId: scenario.id, prompt: producer.prompt, chain, params };

package/dist/ai/plan-card.js

@@ -4,14 +4,15 @@
  * conversation mode. Decisions come from the knowledge base either way.
  */
 import pc from 'picocolors';
-import { t } from '../i18n.js';
+import { estimateGenerationCredits, isP2, normalizeModel } from '../knowledge/models.js';
+import { buildStepRequest } from '../core/requests.js';
 import { getStep } from '../knowledge/chains.js';
 import { isComplexConvert } from '../knowledge/params.js';
 import { getScenario } from '../knowledge/scenarios.js';
 const GENERATION_DESCRIBE = {
-    text_to_model: { zh: '文本生成 3D 模型', en: 'generate a 3D model from text' },
-    image_to_model: { zh: '单图生成 3D 模型', en: 'generate a 3D model from one image' },
-    multiview_to_model: { zh: '多视图生成 3D 模型', en: 'generate a 3D model from multiple views' },
+    text_to_model: 'generate a 3D model from text',
+    image_to_model: 'generate a 3D model from one image',
+    multiview_to_model: 'generate a 3D model from multiple views',
 };
 /** Keys that describe the input itself (already shown on the "input" line). */
 const INPUT_KEYS = new Set(['prompt', 'input', 'inputs']);
@@ -19,6 +20,8 @@ const INPUT_KEYS = new Set(['prompt', 'input', 'inputs']);
 export function cardFromMakePlan(plan, opts) {
     const steps = [];
     const genParams = {};
+    const notes = [...plan.warnings];
+    const chain = [];
     if (plan.generation) {
         const { taskType, request } = plan.generation;
         const args = {};
@@ -33,26 +36,46 @@ export function cardFromMakePlan(plan, opts) {
         steps.push({
             name: importDef ? importDef.name : taskType.replace(/_/g, '-'),
             endpoint: request.endpoint,
-            describe: importDef ? t(importDef.describe) : t(GENERATION_DESCRIBE[taskType] ?? { zh: '生成', en: 'generate' }),
+            describe: importDef ? importDef.describe : GENERATION_DESCRIBE[taskType] ?? 'generate',
             args,
         });
     }
     for (const spec of plan.chain) {
         const def = getStep(spec.step);
+        const built = buildStepRequest(spec.step, '<upstream>', spec.args);
+        const args = { ...built.request.payload };
+        delete args.input;
+        notes.push(...built.warnings);
+        chain.push({ step: def?.name ?? spec.step, args });
         steps.push({
             name: spec.step,
             endpoint: def?.endpoint ?? '',
-            describe: def ? t(def.describe) : '',
-            args: spec.args,
+            describe: def ? def.describe : '',
+            args,
         });
     }
     const scenario = opts.scenario ? getScenario(opts.scenario) : undefined;
-    const notes = [];
+    // Static tips are valid only when the scenario's assumptions survived normalization.
+    if (scenario && plan.model && normalizeModel(plan.model) === normalizeModel(scenario.model) &&
+        Object.entries(scenario.genParams).every(([key, value]) => genParams[key] === value) &&
+        JSON.stringify(plan.chain) === JSON.stringify(scenario.chain)) {
+        notes.unshift(...scenario.notes);
+    }
+    // Advertise actual selected outputs, never optional scenario formats or removed quads.
+    const generated = plan.generation && Object.hasOwn(GENERATION_DESCRIBE, plan.generation.taskType)
+        ? [genParams.quad === true ? 'FBX' : 'GLB'] : [];
+    let deliverables = generated;
+    for (const spec of chain) {
+        if (getStep(spec.step)?.passthrough)
+            continue;
+        const format = spec.step === 'convert' ? (spec.args.quad === true ? 'FBX' : spec.args.format)
+            : spec.step === 'rig' ? spec.args.out_format : undefined;
+        deliverables = typeof format === 'string' ? [format.toUpperCase()] : [];
+    }
+    if (plan.downloadGeneration)
+        deliverables = [...new Set([...generated, ...deliverables])];
     if (opts.candidates && opts.candidates > 1) {
-        notes.push(t({
-            zh: `并行生成 ${opts.candidates} 个候选(不同 seed),选中一个后再继续加工链`,
-            en: `${opts.candidates} candidates in parallel (distinct seeds); pick one before the chain continues`,
-        }));
+        notes.push(`${opts.candidates} candidates in parallel (distinct seeds); pick one before the chain continues`);
     }
     // Task refs (@last / @name) resolve to an id the human has not seen yet — show it.
     let inputSummary = opts.inputs.join(' ');
@@ -64,39 +87,54 @@ export function cardFromMakePlan(plan, opts) {
         scenario: opts.scenario,
         model: plan.model,
         modelReason: plan.modelReason,
+        taskType: plan.generation?.taskType,
+        candidates: opts.candidates,
         genParams,
-        chain: plan.chain,
-        deliverables: scenario?.deliverables ?? [],
-        notes,
+        chain,
+        deliverables,
+        notes: [...new Set(notes)],
         steps,
     };
 }
+/** List-price credits for the generation step × candidates; undefined when no official price applies. */
+export function generationCreditsEstimate(card) {
+    if (!card.model || !card.taskType)
+        return undefined;
+    const unit = estimateGenerationCredits(card.model, card.taskType, card.genParams);
+    return unit === undefined ? undefined : unit * (card.candidates && card.candidates > 1 ? card.candidates : 1);
+}
 /** Cost-impact annotations derived from the parameter set. */
 export function costNotes(card) {
-    const notes = [];
+    const total = generationCreditsEstimate(card);
+    const n = card.candidates && card.candidates > 1 ? card.candidates : 1;
+    const amount = n > 1 && total !== undefined ? `${n} × ${total / n} = ${total}` : String(total);
+    const chainNote = card.chain.length > 0;
+    const notes = [total === undefined ? 'cost not estimated (not zero credits); notes below are cost impacts only; check regional official pricing and balance before running' : `estimated generation cost: ${amount} credits (official list price${chainNote ? '; chain steps not estimated' : ''})`];
     const params = card.genParams;
     if (params.texture === false) {
-        notes.push(t({ zh: '白模生成:不消耗贴图积分', en: 'bare geometry: no texture credits' }));
+        notes.push('bare geometry: no texture credits');
     }
     if (params.texture_quality === 'detailed' || params.texture_quality === 'extreme') {
-        notes.push(t({ zh: `贴图质量 ${params.texture_quality}:价签更高`, en: `texture_quality ${params.texture_quality}: higher price tier` }));
+        notes.push(`texture_quality ${params.texture_quality}: higher price tier`);
     }
     if (params.geometry_quality === 'detailed') {
-        notes.push(t({ zh: 'geometry detailed(Ultra):加收 HD credit', en: 'geometry detailed (Ultra): extra HD credit' }));
+        notes.push('geometry detailed (Ultra): extra HD credit');
     }
     if (params.quad === true) {
-        notes.push(t({ zh: 'quad 四边面:价签更高,输出 FBX', en: 'quad topology: higher price tier, FBX output' }));
+        notes.push(card.model && isP2(card.model)
+            ? 'quad topology: FBX output'
+            : 'quad topology: higher price tier, FBX output');
     }
     if (params.generate_parts === true) {
-        notes.push(t({ zh: '分件生成:价签更高,出裸几何', en: 'part generation: higher price tier, bare geometry' }));
+        notes.push('part generation: higher price tier, bare geometry');
     }
     for (const step of card.chain) {
         if (step.step === 'convert' && isComplexConvert(step.args)) {
-            notes.push(t({ zh: 'convert 非默认参数:按 complex 价签计费', en: 'non-default convert options bill as complex convert' }));
+            notes.push('non-default convert options bill as complex convert');
         }
         if (step.step === 'retarget') {
             const count = Array.isArray(step.args.animations) ? step.args.animations.length : 1;
-            notes.push(t({ zh: `retarget ${count} 条动画:按条计费`, en: `retarget ${count} animation(s): billed per animation` }));
+            notes.push(`retarget ${count} animation(s): billed per animation`);
         }
     }
     return notes;
@@ -105,18 +143,18 @@ export function costNotes(card) {
 export function renderPlanCard(card) {
     const scenario = card.scenario ? getScenario(card.scenario) : undefined;
     const lines = [];
-    const title = t({ zh: '方案卡', en: 'Plan' });
+    const title = 'Plan';
     lines.push(pc.bold(`── ${title} ──────────────────────────`));
-    lines.push(`${t({ zh: '输入', en: 'input' })}: ${card.inputSummary}`);
+    lines.push(`${'input'}: ${card.inputSummary}`);
     if (scenario)
-        lines.push(`${t({ zh: '场景', en: 'scenario' })}: ${scenario.id} (${t(scenario.label)})`);
+        lines.push(`${'scenario'}: ${scenario.id} (${scenario.label})`);
     if (card.model) {
-        lines.push(`${t({ zh: '模型', en: 'model' })}: ${card.model}${card.modelReason ? pc.dim(` — ${card.modelReason}`) : ''}`);
+        lines.push(`${'model'}: ${card.model}${card.modelReason ? pc.dim(` — ${card.modelReason}`) : ''}`);
     }
     const fmtArgs = (args) => Object.entries(args).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(' ');
     if (card.steps && card.steps.length > 0) {
         // Numbered step list: what each call does, which endpoint, with which args.
-        lines.push(`${t({ zh: '步骤', en: 'steps' })}:`);
+        lines.push(`${'steps'}:`);
         card.steps.forEach((step, i) => {
             lines.push(`  ${i + 1}. ${step.name}  ${pc.dim(`POST ${step.endpoint}`)}${step.describe ? ` — ${step.describe}` : ''}`);
             if (Object.keys(step.args).length > 0)
@@ -126,28 +164,28 @@ export function renderPlanCard(card) {
     else {
         const params = Object.entries(card.genParams);
         if (params.length > 0) {
-            lines.push(`${t({ zh: '参数', en: 'params' })}: ${fmtArgs(card.genParams)}`);
+            lines.push(`${'params'}: ${fmtArgs(card.genParams)}`);
         }
         if (card.chain.length > 0) {
             const chainStr = card.chain
                 .map((s) => (Object.keys(s.args).length > 0 ? `${s.step}(${Object.entries(s.args).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(',')})` : s.step))
                 .join(' → ');
-            lines.push(`${t({ zh: '加工链', en: 'chain' })}: ${chainStr}`);
+            lines.push(`${'chain'}: ${chainStr}`);
         }
     }
     if (card.deliverables.length > 0) {
-        lines.push(`${t({ zh: '交付物', en: 'deliverables' })}: ${card.deliverables.join(', ')}`);
+        lines.push(`${'deliverables'}: ${card.deliverables.join(', ')}`);
     }
     const cost = costNotes(card);
     if (cost.length > 0) {
-        lines.push(`${t({ zh: '成本影响', en: 'cost impact' })}:`);
+        lines.push(`${'cost impact'}:`);
         for (const note of cost)
             lines.push(`  · ${note}`);
     }
     for (const note of card.notes)
         lines.push(pc.dim(`  ${note}`));
     if (card.expertNotes && card.expertNotes.length > 0) {
-        lines.push(`${t({ zh: '专家意见', en: 'expert notes' })}:`);
+        lines.push(`${'expert notes'}:`);
         for (const note of card.expertNotes)
             lines.push(`  · ${note}`);
     }

package/dist/ai/wizard.js

@@ -6,31 +6,27 @@
 import * as p from '@clack/prompts';
 import { CliError, UsageError } from '../core/errors.js';
 import { isInteractive } from '../core/output.js';
-import { t, tList } from '../i18n.js';
 import { EXIT } from '../knowledge/error-catalog.js';
 import { CAPABILITY_DEFAULTS } from '../knowledge/models.js';
 import { getScenario, SCENARIOS } from '../knowledge/scenarios.js';
 export async function runWizard(initialPrompt) {
     if (!isInteractive()) {
-        throw new UsageError(t({
-            zh: '向导需要交互终端;无头环境请直接用 tripo make --for <场景> 或配置 LLM 后用 tripo ai --yes',
-            en: 'the wizard needs an interactive terminal; headless callers should use "tripo make --for <scenario>" instead',
-        }));
+        throw new UsageError('the wizard needs an interactive terminal; headless callers should use "tripo make --for <scenario>" instead');
     }
     p.intro('tripo ai');
     let prompt = initialPrompt?.trim() ?? '';
     if (!prompt) {
         const answer = await p.text({
-            message: t({ zh: '想做个什么?一句话描述(或图片路径)', en: 'What do you want to make? one sentence (or an image path)' }),
-            validate: (v) => (v && v.trim().length > 0 ? undefined : t({ zh: '说点什么吧', en: 'say something' })),
+            message: 'What do you want to make? one sentence (or an image path)',
+            validate: (v) => (v && v.trim().length > 0 ? undefined : 'say something'),
         });
         if (p.isCancel(answer))
             throw new CliError('cancelled', EXIT.FATAL);
         prompt = answer.trim();
     }
     const scenarioAnswer = await p.select({
-        message: t({ zh: '用在什么地方?', en: 'What is it for?' }),
-        options: SCENARIOS.map((s) => ({ value: s.id, label: `${t(s.label)} — ${t(s.description)}` })),
+        message: 'What is it for?',
+        options: SCENARIOS.map((s) => ({ value: s.id, label: `${s.label} — ${s.description}` })),
     });
     if (p.isCancel(scenarioAnswer))
         throw new CliError('cancelled', EXIT.FATAL);
@@ -38,12 +34,12 @@ export async function runWizard(initialPrompt) {
     let engine;
     if (scenarioAnswer === 'game-mobile' || scenarioAnswer === 'game-pc') {
         const engineAnswer = await p.select({
-            message: t({ zh: '目标引擎/软件?', en: 'Target engine/software?' }),
+            message: 'Target engine/software?',
             options: [
                 { value: 'unity', label: 'Unity' },
                 { value: 'unreal', label: 'Unreal' },
                 { value: 'blender', label: 'Blender' },
-                { value: 'any', label: t({ zh: '不确定/通用', en: 'not sure / generic' }) },
+                { value: 'any', label: 'not sure / generic' },
             ],
         });
         if (p.isCancel(engineAnswer))
@@ -53,7 +49,7 @@ export async function runWizard(initialPrompt) {
     let animations = false;
     if (scenarioAnswer !== 'print' && scenarioAnswer !== 'film') {
         const animAnswer = await p.confirm({
-            message: t({ zh: '需要骨骼/动画吗?', en: 'Do you need a skeleton / animations?' }),
+            message: 'Do you need a skeleton / animations?',
             initialValue: scenarioAnswer === 'anim',
         });
         if (p.isCancel(animAnswer))
@@ -65,11 +61,11 @@ export async function runWizard(initialPrompt) {
         inputSummary: prompt,
         scenario: scenario.id,
         model: scenario.model,
-        modelReason: t({ zh: '场景预设', en: 'scenario preset' }),
+        modelReason: 'scenario preset',
         genParams: scenario.genParams,
         chain,
         deliverables: scenario.deliverables,
-        notes: [...tList(scenario.notes), ...notes],
+        notes: [...scenario.notes, ...notes],
     };
     return { card, options: { prompt, scenario: scenario.id, chain } };
 }
@@ -82,11 +78,11 @@ export function adjustChain(scenarioId, engine, animations) {
         const rigArgs = { model: CAPABILITY_DEFAULTS.rig, out_format: 'fbx' };
         if (engine === 'unity') {
             rigArgs.spec = 'unity';
-            notes.push(t({ zh: 'Unity Humanoid → spec=unity', en: 'Unity Humanoid → spec=unity' }));
+            notes.push('Unity Humanoid → spec=unity');
         }
         else if (engine === 'unreal') {
             rigArgs.spec = 'unreal';
-            notes.push(t({ zh: 'Unreal Mannequin → spec=unreal', en: 'Unreal Mannequin → spec=unreal' }));
+            notes.push('Unreal Mannequin → spec=unreal');
         }
         chain = [
             ...chain.filter((s) => s.step !== 'convert'),
@@ -94,7 +90,7 @@ export function adjustChain(scenarioId, engine, animations) {
             { step: 'rig', args: rigArgs },
             { step: 'retarget', args: { animations: ['preset:idle', 'preset:walk'], out_format: 'fbx' } },
         ];
-        notes.push(t({ zh: '动画链输出 FBX(骨骼+动画)', en: 'animation chain outputs FBX (skeleton + animations)' }));
+        notes.push('animation chain outputs FBX (skeleton + animations)');
     }
     if (engine && !animations) {
         const convert = chain.find((s) => s.step === 'convert');

package/dist/commands/account.js

@@ -1,17 +1,13 @@
 /** `tripo balance` / `tripo usage` — account visibility. */
 import { TripoClient } from '../core/client.js';
 import { emitResult } from '../core/output.js';
-import { t } from '../i18n.js';
 export function registerAccountCommands(program) {
     program
         .command('balance')
         .description('show available and frozen credits')
         .action(async () => {
         const data = await new TripoClient().getBalance();
-        emitResult(data, t({
-            zh: `余额 ${data.balance} 积分(冻结 ${data.frozen})`,
-            en: `balance: ${data.balance} credits (${data.frozen} frozen)`,
-        }));
+        emitResult(data, `balance: ${data.balance} credits (${data.frozen} frozen)`);
     });
     program
         .command('usage')
@@ -22,6 +18,6 @@ export function registerAccountCommands(program) {
         const human = items
             .map((i) => `${(i.created_at ?? '').slice(0, 19).padEnd(20)} ${i.type.padEnd(24)} ${String(i.credits_consumed ?? 0).padStart(6)} cr  ${i.task_id}`)
             .join('\n');
-        emitResult(items, human || t({ zh: '暂无用量记录', en: 'no usage yet' }));
+        emitResult(items, human || 'no usage yet');
     });
 }

package/dist/commands/ai.js

@@ -9,10 +9,10 @@ import * as p from '@clack/prompts';
 import { resolveReference } from '../config/history.js';
 import { CliError } from '../core/errors.js';
 import { isInteractive, isYes, log, warn } from '../core/output.js';
-import { t } from '../i18n.js';
 import { EXIT } from '../knowledge/error-catalog.js';
+import { getScenario } from '../knowledge/scenarios.js';
 import { executeMake, planMake } from '../pipeline/make.js';
-import { renderPlanCard } from '../ai/plan-card.js';
+import { cardFromMakePlan, renderPlanCard } from '../ai/plan-card.js';
 import { resolveLlmConfig } from '../ai/llm.js';
 import { buildExpertPlan } from '../ai/experts.js';
 import { runWizard } from '../ai/wizard.js';
@@ -22,7 +22,7 @@ export function registerAiCommand(program) {
     const cmd = program
         .command('ai')
         .description('describe what you want in natural language; experts plan it, you confirm, it runs')
-        .argument('[request...]', 'e.g. "给我的手游做一个低模骑士,要跑步动画"')
+        .argument('[request...]', 'e.g. "a low-poly knight for my mobile game, with a run animation"')
         .option('--wizard', 'force wizard mode even when an LLM is configured');
     withTaskOptions(cmd);
     cmd.action(async (request, flags) => {
@@ -31,14 +31,15 @@ export function registerAiCommand(program) {
         let card;
         let makeOptions;
         if (llm && !flags.wizard && text) {
-            log(t({ zh: `对话模式(${llm.model})…`, en: `conversation mode (${llm.model})…` }));
+            log(`conversation mode (${llm.model})…`);
             try {
-                const plan = await buildExpertPlan(text, isInteractive() ? askUser : undefined);
+                const plan = await buildExpertPlan(text, isInteractive() ? askUser : undefined, flags.param);
                 card = plan.card;
                 makeOptions = {
                     inputs: [plan.prompt],
                     scenario: plan.scenarioId,
                     chain: plan.chain,
+                    model: plan.card.model,
                     params: plan.params,
                     name: flags.name,
                     outDir: flags.out,
@@ -47,10 +48,7 @@ export function registerAiCommand(program) {
                 };
             }
             catch (err) {
-                warn(t({
-                    zh: `LLM 编排失败(${err instanceof Error ? err.message : err}),回落到向导模式`,
-                    en: `LLM planning failed (${err instanceof Error ? err.message : err}); falling back to the wizard`,
-                }));
+                warn(`LLM planning failed (${err instanceof Error ? err.message : err}); falling back to the wizard`);
                 const wizard = await runWizard(text);
                 card = wizard.card;
                 makeOptions = wizardToOptions(wizard.options, flags);
@@ -59,24 +57,28 @@ export function registerAiCommand(program) {
         else {
             // The wizard is interactive by nature — never enter it headless.
             if (!isInteractive()) {
-                throw new CliError(t({
-                    zh: '向导模式需要交互终端;无头环境请用 tripo make --for <场景>(或配置 llm.base_url/llm.model 走对话模式)',
-                    en: 'wizard mode needs an interactive terminal; headless callers should use "tripo make --for <scenario>" (or configure llm.base_url/llm.model for conversation mode)',
-                }), EXIT.USAGE);
+                throw new CliError('wizard mode needs an interactive terminal; headless callers should use "tripo make --for <scenario>" (or configure llm.base_url/llm.model for conversation mode)', EXIT.USAGE);
             }
             const wizard = await runWizard(text || undefined);
             card = wizard.card;
             makeOptions = wizardToOptions(wizard.options, flags);
         }
+        // An explicit chain counts as a --then override in planMake, which drops the preset's dual delivery.
+        const preset = getScenario(makeOptions.scenario ?? '');
+        if (preset && JSON.stringify(makeOptions.chain) === JSON.stringify(preset.chain))
+            makeOptions.chain = undefined;
+        const client = newClient();
+        const preview = await planMake(client, { ...makeOptions, dryRun: true });
+        card = { ...card, ...cardFromMakePlan(preview, makeOptions), notes: card.notes };
+        makeOptions.model = preview.model;
         process.stderr.write(renderPlanCard(card) + '\n');
         if (!isYes()) {
-            const go = await p.confirm({ message: t({ zh: '按方案执行?', en: 'Run this plan?' }) });
+            const go = await p.confirm({ message: 'Run this plan?' });
             if (p.isCancel(go) || !go) {
-                log(t({ zh: '已取消,未消耗积分', en: 'cancelled; no credits spent' }));
+                log('cancelled; no credits spent');
                 return;
             }
         }
-        const client = newClient();
         const plan = await planMake(client, makeOptions);
         const outcome = await executeMake(client, plan, makeOptions);
         emitMakeOutcome({ results: [outcome.primary], chainResults: outcome.chainResults, stoppedEarly: outcome.stoppedEarly });