@wji.ai/cli 0.5.1 → 0.6.0

package/README.md

@@ -117,8 +117,12 @@ Run `wji <group> --help` for the full option list.
 
 ## Conventions
 
-- **`--json`** on any command prints the raw API response and nothing else, so
-  everything composes with `jq`.
+- **`--json`** on any command prints JSON and nothing else, so everything
+  composes with `jq`. List and get commands print the **`standard`** level by
+  default (ids, names, status, media urls, long text clipped to 200 chars,
+  `content` summarised with `truncated: true`). Add **`--detail full`** (or set
+  `WJI_DETAIL=full`) for the raw API response, `--detail brief` for id lists.
+  Human table output is never affected.
 - **`@file` and `-`** work anywhere a long text or JSON value is expected:
   `-p @prompt.txt`, `--content @node.json`, `-p -` to read stdin.
 - **`--set key=value`** sends arbitrary fields; dotted keys nest
@@ -244,6 +248,7 @@ Skill refs are `system:<key>` or `user:<skillId>` (a bare id is treated as `user
 | Generation submissions | image 30 / video 10 / audio 20 per minute, per user or key |
 | Generation queue | queued + running jobs: FREE 3 / VIP 10 / SVIP 25 → HTTP 429 |
 | Pagination | `--limit` ≤100; `-1` returns at most 500 except on opt-in endpoints |
+| Detail levels | `?detail=brief\|standard\|full` on workspace, fsnode, model and history reads; the API defaults to `full`, the CLI's `--json` to `standard` |
 | Batches | `asset status` is sent 100 ids at a time; `asset summary` ≤100 ids |
 | Skills | zip ≤5MB, ≤200 files, ≤2MB per `.md`, ≤20MB total, 50 per account |
 | Creation caps | 50 workspaces, 3 organizations per account |

package/dist/commands/canvas.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
 import { confirm, parseKeyValues, readValue } from '../core/prompt.js';
-import { color, detail, info, isJsonMode, printJson, relativeTime, render, success, table, truncate, warn } from '../core/output.js';
+import { clipText, color, detail, detailLevel, info, isJsonMode, printJson, relativeTime, render, success, table, truncate, warn } from '../core/output.js';
 import { pollHistory, reportHistory, resolveAssets } from './gen.js';
 import { loadMembers, memberLabel, resolveMember } from '../core/members.js';
 import { fetchModels } from './model.js';
@@ -315,6 +315,53 @@ export function describe(canvas, node) {
         outgoing: canvas.edges.filter((e) => e.fromNodeId === node.id).map((e) => e.toNodeId),
     };
 }
+/**
+ * The canvas commands always load the full canvas (edits and generation need
+ * every field), so --detail is applied here, to the JSON they print. Mirrors
+ * the backend's canvas_list_nodes levels.
+ */
+export function trimDescribed(row, level = detailLevel()) {
+    if (!level || level === 'full')
+        return row;
+    if (level === 'brief') {
+        return compactRow({
+            id: row.id,
+            kind: row.kind,
+            name: row.name,
+            tag: row.tag,
+            mode: row.mode,
+            status: row.status,
+            assetId: row.assetId,
+            position: row.position,
+            references: row.references.map((r) => ({ nodeId: r.nodeId, label: r.label })),
+            outgoing: row.outgoing,
+        });
+    }
+    const g = row.generate;
+    return compactRow({
+        ...row,
+        text: row.text === undefined ? undefined : clipText(row.text) ?? '',
+        error: typeof row.error === 'string' ? clipText(row.error) : row.error,
+        generate: g
+            ? compactRow({
+                prompt: clipText(g.prompt),
+                model: g.model,
+                ratio: g.ratio,
+                resolution: g.resolution,
+                duration: g.duration,
+                historyId: g.historyId,
+                pendingAssetId: g.pendingAssetId,
+            })
+            : undefined,
+    });
+}
+function compactRow(value) {
+    const out = {};
+    for (const key of Object.keys(value))
+        if (value[key] !== undefined)
+            out[key] = value[key];
+    return out;
+}
 // ── models ──────────────────────────────────────────────────────────────────
 /** An audio node is fed by either an `audio` or a `tts` model — the backend tags voice models `tts`. */
 const KIND_FEATURES = { audio: ['audio', 'tts'] };
@@ -1022,7 +1069,7 @@ export function canvasCommand(globals) {
                 .filter((id) => loaded.byId.has(id))
                 .map((id) => describe(loaded, loaded.byId.get(id)));
         }
-        const out = { ...res, state: { ...state, canvasName }, selected };
+        const out = { ...res, state: { ...state, canvasName }, selected: selected.map((n) => trimDescribed(n)) };
         render(out, () => {
             const seconds = Math.max(0, Math.round((new Date(state.expiresAt).getTime() - Date.now()) / 1000));
             detail([
@@ -1249,7 +1296,7 @@ export function canvasCommand(globals) {
             .filter((n) => !nameRe || nameRe.test(n.name))
             .map((n) => describe(cv, n))
             .filter((n) => (colors ? !!n.tag && colors.has(n.tag.color) : opts.untagged ? !n.tag : true));
-        render({ canvas: { id: cv.id, name: cv.name, workspaceId: cv.workspaceId }, nodes: rows }, () => {
+        render({ canvas: { id: cv.id, name: cv.name, workspaceId: cv.workspaceId }, nodes: rows.map((n) => trimDescribed(n)) }, () => {
             info(color.dim(`${cv.name} (${cv.id}) · ${rows.length} node(s) · ${cv.edges.length} edge(s)`));
             nodeTable(rows);
         });
@@ -1283,13 +1330,13 @@ export function canvasCommand(globals) {
     });
     canvas
         .command('get <nodeId>')
-        .description('One node in full, with its references')
+        .description('One node with its references (--detail full for the whole generate / text)')
         .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
         .action(async (id, opts) => {
         const c = client();
         const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
         const n = describe(cv, requireNode(cv, id));
-        render(n, () => printNode(n));
+        render(trimDescribed(n), () => printNode(n));
     });
     canvas
         .command('edges')

package/dist/commands/fsnode.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
 import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
-import { color, detail, info, relativeTime, render, success, table, truncate } from '../core/output.js';
+import { color, detail, detailLevel, info, relativeTime, render, success, table, truncate } from '../core/output.js';
 import { printTree } from './workspace.js';
 /** Nested plain objects merge; arrays and scalars are replaced. */
 function deepMerge(base, patch) {
@@ -22,7 +22,10 @@ export function fsCommand(globals) {
         .action(async (key, opts) => {
         const client = new WjiClient(globals());
         const path = key ? `/fsnode/root/${key}` : '/fsnode/root';
-        const node = await client.get(path, opts.depth ? { depth: Number(opts.depth) } : undefined);
+        const node = await client.get(path, {
+            depth: opts.depth ? Number(opts.depth) : undefined,
+            detail: detailLevel(),
+        });
         render(node, (n) => (opts.depth ? printTree(n) : printNode(n)));
     });
     fs.command('ls <id>')
@@ -34,6 +37,7 @@ export function fsCommand(globals) {
         const result = await client.get(`/fsnode/list/${id}/children`, {
             limit: opts.limit ? Number(opts.limit) : undefined,
             scope: opts.scope,
+            detail: detailLevel(),
         });
         const rows = Array.isArray(result) ? result : result?.data || [];
         render(result, () => table(rows, [
@@ -50,15 +54,18 @@ export function fsCommand(globals) {
         .option('-d, --depth <n>', 'levels to expand')
         .action(async (id, opts) => {
         const client = new WjiClient(globals());
-        const node = await client.get(`/fsnode/list/${id}/tree`, opts.depth ? { depth: Number(opts.depth) } : undefined);
+        const node = await client.get(`/fsnode/list/${id}/tree`, {
+            depth: opts.depth ? Number(opts.depth) : undefined,
+            detail: detailLevel(),
+        });
         render(node, (n) => printTree(n));
     });
     fs.command('get <id>')
-        .description('Show one node (comma-separate ids for a batch)')
+        .description('Show one node (comma-separate ids for a batch; --detail full for the whole content)')
         .option('--scope <scope>', 'server-side scope filter')
         .action(async (id, opts) => {
         const client = new WjiClient(globals());
-        const node = await client.get(`/fsnode/list/${id}`, { scope: opts.scope });
+        const node = await client.get(`/fsnode/list/${id}`, { scope: opts.scope, detail: detailLevel() });
         render(node, (n) => (Array.isArray(n) ? n.forEach(printNode) : printNode(n)));
     });
     fs.command('path <id>')
@@ -232,7 +239,7 @@ export function datasetCommand(globals) {
         .description('List dataset nodes in a folder')
         .action(async (folderId) => {
         const client = new WjiClient(globals());
-        const result = await client.get(`/fsnode/list/${folderId}/children`);
+        const result = await client.get(`/fsnode/list/${folderId}/children`, { detail: detailLevel() });
         const rows = (Array.isArray(result) ? result : result?.data || []).filter((n) => n.mimetype === 'workspace/dataset' || n.type === 'file');
         render(rows, () => table(rows, [
             { header: 'id', value: (n) => n.id },

package/dist/commands/gen.js

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
 import { confirm, parseKeyValues, readJson, readValue } from '../core/prompt.js';
-import { color, detail, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
+import { color, detail, detailLevel, info, isJsonMode, printJson, render, success, table, truncate, warn } from '../core/output.js';
 const READY = 1;
 const CANCELLED = -1;
 /** `--ref abc123`, `--ref abc123:hero`, `--ref abc123:hero:0.6` */
@@ -254,6 +254,7 @@ export function historyCommand(globals) {
             bookmarked: opts.bookmarked ? true : undefined,
             page: Number(opts.page),
             limit: Number(opts.limit),
+            detail: detailLevel(),
         });
         render(result, (r) => {
             table(r.data || [], [
@@ -284,7 +285,7 @@ export function historyCommand(globals) {
             }));
         }
         else {
-            history = await client.get(`/ai/assets/history/list/${id}`);
+            history = await client.get(`/ai/assets/history/list/${id}`, { detail: detailLevel() });
             assets = await resolveAssets(client, history);
         }
         render({ ...history, images: assets }, () => reportHistory(history, assets));

package/dist/commands/model.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
-import { color, detail, info, render, table, truncate, warn } from '../core/output.js';
+import { color, detail, detailLevel, info, render, table, truncate, warn } from '../core/output.js';
 const FEATURES = [
     'text',
     'image',
@@ -24,6 +24,7 @@ export async function fetchModels(client, opts) {
     const features = opts.features?.length ? opts.features : FEATURES;
     const list = await client.get(`/ai/model/list/${features.join(',')}`, {
         workspaceId: client.workspace(opts.workspace),
+        detail: opts.detail,
     });
     return Array.isArray(list) ? list : list?.data || [];
 }
@@ -41,6 +42,7 @@ export function modelCommand(globals) {
         let rows = await fetchModels(client, {
             features: opts.feature,
             workspace: opts.workspace,
+            detail: detailLevel(),
         });
         if (!opts.all)
             rows = rows.filter((m) => m.enabled !== false && !m.hidden);
@@ -70,7 +72,7 @@ export function modelCommand(globals) {
         .option('-w, --workspace <id>', 'resolve pricing/access for a workspace')
         .action(async (name, opts) => {
         const client = new WjiClient(globals());
-        const rows = await fetchModels(client, { workspace: opts.workspace });
+        const rows = await fetchModels(client, { workspace: opts.workspace, detail: detailLevel() });
         // `name` is not unique across providers; `nickname` is, so prefer it.
         const matches = rows.filter((m) => m.nickname === name || m.name === name);
         if (!matches.length)

package/dist/commands/workspace.js

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import { WjiClient } from '../core/client.js';
 import { updateProfile } from '../core/config.js';
 import { confirm, parseKeyValues } from '../core/prompt.js';
-import { color, detail, info, relativeTime, render, success, table, truncate } from '../core/output.js';
+import { color, detail, detailLevel, info, relativeTime, render, success, table, truncate } from '../core/output.js';
 import { loadMembers, memberLabel, resolveMember } from '../core/members.js';
 /** App tokens accepted by `--app`; mirrors WorkspaceApplication on the backend. */
 const APPS = {
@@ -54,6 +54,7 @@ export function workspaceCommand(globals) {
             scope: opts.scope,
             page: Number(opts.page),
             limit: Number(opts.limit),
+            detail: detailLevel(),
         });
         const current = client.workspace();
         render(result, (r) => {
@@ -77,7 +78,9 @@ export function workspaceCommand(globals) {
         .description('Show a workspace (defaults to the selected one)')
         .action(async (id) => {
         const client = new WjiClient(globals());
-        const w = await client.get(`/workspace/list/${client.requireWorkspace(id)}`);
+        const w = await client.get(`/workspace/list/${client.requireWorkspace(id)}`, {
+            detail: detailLevel(),
+        });
         render(w, () => detail([
             ['id', w.id],
             ['name', w.name],
@@ -173,7 +176,7 @@ export function workspaceCommand(globals) {
         const path = opts.app
             ? `/workspace/list/${wsId}/fs/${opts.app}`
             : `/workspace/list/${wsId}/fs`;
-        const root = await client.get(path);
+        const root = await client.get(path, { detail: detailLevel() });
         render(root, (node) => printTree(node));
     });
     // ── apps ───────────────────────────────────────────────────────────────────

package/dist/core/output.js

@@ -17,6 +17,35 @@ export function setJsonMode(on) {
 export function isJsonMode() {
     return jsonMode;
 }
+const DETAIL_LEVELS = ['brief', 'standard', 'full'];
+/**
+ * Global --detail (or WJI_DETAIL). Unset means "standard when printing JSON,
+ * nothing (server default = full) for human output", so tables are unchanged.
+ */
+let detailMode;
+export function setDetailMode(raw) {
+    if (raw === undefined || raw === '') {
+        detailMode = undefined;
+        return;
+    }
+    const level = String(raw).toLowerCase();
+    if (!DETAIL_LEVELS.includes(level)) {
+        throw new Error(`--detail must be one of ${DETAIL_LEVELS.join(', ')} (got "${raw}")`);
+    }
+    detailMode = level;
+}
+export function detailLevel() {
+    if (detailMode)
+        return detailMode;
+    return jsonMode ? 'standard' : undefined;
+}
+/** Clip long text the way the server does at `standard` (200 chars + …). */
+export function clipText(value, max = 200) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    const s = String(value);
+    return s.length <= max ? s : `${s.slice(0, max)}…`;
+}
 export function printJson(value) {
     process.stdout.write(JSON.stringify(value, null, 2) + '\n');
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { ApiError } from './core/client.js';
-import { color, setJsonMode } from './core/output.js';
+import { color, setDetailMode, setJsonMode } from './core/output.js';
 import { authCommand } from './commands/auth.js';
 import { configCommand } from './commands/config.js';
 import { orgCommand } from './commands/org.js';
@@ -34,7 +34,8 @@ program
     .option('--org <orgId>', 'organization context (X-Org-Id)')
     .option('--no-org', 'force personal context')
     .option('--locale <locale>', 'response language (cht, chs, en)')
-    .option('--json', 'print raw JSON instead of tables')
+    .option('--json', 'print JSON instead of tables (standard detail unless --detail is given)')
+    .option('--detail <level>', 'how much to return: brief | standard | full (default standard for --json; env WJI_DETAIL)')
     .configureHelp({ sortSubcommands: true });
 /**
  * Global flags live on the root command, but subcommand actions run before
@@ -51,10 +52,12 @@ const globals = () => {
         // commander turns `--no-org` into org === false
         personal: opts.org === false,
         locale: opts.locale,
+        detail: opts.detail,
     };
 };
 program.hook('preAction', () => {
     setJsonMode(!!program.opts().json);
+    setDetailMode(program.opts().detail ?? process.env.WJI_DETAIL);
 });
 program.addCommand(authCommand(globals));
 program.addCommand(configCommand(globals));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wji.ai/cli",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Command line interface for the WJI AI platform",
   "license": "UNLICENSED",
   "author": "WJI AI",

package/skill/ads/reference/models.md

@@ -24,6 +24,9 @@ strengths, not platform guarantees.
 | `marketing-studio-image` | auto · 1:1 · 3:2 · 2:3 · 4:3 · 3:4 · 16:9 · 9:16 · 21:9 | 1k · 2k · 4k | 8 | fair | tuned for a commercial "marketing" look; cheapest 4K |
 | `runninghub-midjourney-v7` | 1:1 · 4:3 · 3:2 · 16:9 · 3:4 · 2:3 · 9:16 | fixed; quality 1 / 2 / 4 | 5 image + 5 omni + 5 style, weighted | weak; do not rely on it for labels | mood boards, style frames; negative prompt |
 | `runninghub-midjourney-v8.1` / `v8.2` | same 7 | native 2K | 8.1: 5; 8.2: 2 (first = image ref, second = style ref) | weak | style exploration only; never the packshot |
+| `z-image-uncensored` / `z-image-pro-uncensored` | 1:1 · 2:3 · 3:2 · 3:4 · 4:3 · 9:16 · 16:9 | long edge ≤ 1536 (pro ≤ 2560) | none | fair | uncensored (無審核); only when the brief needs it |
+| `qwen-image-edit-uncensored` | follows the first reference | follows the first reference | 1–3 (first = image to edit) | fair | uncensored instruction edit |
+| `face-swap-uncensored` / `head-swap-uncensored` | follows the target | follows the target | exactly 2: target, then face / head | — | uncensored; swap a talent's face / head onto a shot |
 
 Bold ratios are the only sources of 4:5 and 2:3 on the platform. No image model outputs 1.91:1,
 6:7 or any banner strip.
@@ -40,6 +43,8 @@ Bold ratios are the only sources of 4:5 and 2:3 on the platform. No image model
 | `seedance-2.0` family | same six | 4–15 s, or auto | 480p · 720p · 1080p · 4k | ref variants: images + video + audio | `generate_audio` | the 4K option of the family |
 | `wan-3.0` / `-prime` | 16:9 · 4:3 · 1:1 · 3:4 · 9:16 | 2–30 s, or `autoDuration` | 480P · 720P · 1080P | first / last frame | `audio` on by default | optional "AI Generated" watermark; seed for repeatability |
 | `wan-3.0-ref` / `-prime-ref` | same five | 2–30 s, or auto | as above | 10 images + 5 videos + 5 audios (≤ 15 s total) | `audio` | |
+| `wan-3.0-*-uncensored` (+ `-pro`, `-prime`, `-prime-pro`; each with a `-ref-` twin) | adaptive + the five | 2–30 s, or auto | 480p–1080p; pro: 1080p · 2k · 4k | as `wan-3.0` / `wan-3.0-ref` | `audio` | uncensored (無審核); Ref twins billed on input video + output seconds |
+| `wan-2.7-i2v-uncensored` / `wan-2.2-i2v-uncensored` | follows the input image | 2.7: 2–15 s; 2.2: 5 or 8 s | 2.7: 720p · 1080p; 2.2: 480p · 720p | first frame (2.2 also last frame); 2.7: 1 driving audio | 2.7 `audio` | uncensored; 2.2 is the cheapest video here |
 | `veo-3.1` / `-fast` | 16:9 · 9:16 · auto | 4–8 s | 720p · 1080p · 4k | first / last frame | `generate_audio` | negative prompt available |
 | `veo-3.1-ref` | 16:9 · 9:16 | 8 s fixed | 720p · 1080p · 4k | 1–10 images | `generate_audio` | |
 | `kling-3` / `-pro` | 16:9 · 9:16 · 1:1 | 3–15 s | model default | 7 images, plus first / last frame | `generate_audio` (off by default) | pro = higher quality |

package/skill/short-drama/reference/canvas-recipes.md

@@ -4,6 +4,24 @@
 which row, and in what order the references are connected. Read them as written and substitute the
 tool calls from `operations-wji.md`; `--from A B C` is `fromNodeIds: ['A','B','C']` and the array
 order is the reference order. Everything about rows, `@imageN` order and prompts is identical.
+Build each row with **one `canvas_create_nodes` call**: its `nodes` array takes the fields of
+`canvas_create_node` (minus `canvas`), and `"$i"` in `fromNodeIds` or `nextTo` means item i of the
+same batch (0-based, must come earlier), so a headshot → sheet → voice chain is one call and a
+`characters` canvas of twelve characters is one or two calls instead of fifty. Items are created in
+order; if one fails the result says `failedAt` and the earlier nodes stay on the canvas — fix that
+item and resend from it with real ids (up to 60 nodes a call).
+
+```
+canvas_create_nodes { canvas: CV, nodes: [
+  { kind: "title", text: "C01 林小夏", position: {x: 0, y: 0} },                                        # $0
+  { kind: "image", name: "C01 headshot", position: {x: 400, y: 0},
+    generate: { model: "<image model>", ratio: "1:1", prompt: "<portrait prompt>" } },               # $1
+  { kind: "image", name: "C01 sheet", fromNodeIds: ["$1"],
+    generate: { model: "<image model>", ratio: "16:9", prompt: "@image1 is the face to match … " } }, # $2
+  { kind: "audio", name: "C01 voice", fromNodeIds: ["$1"],
+    generate: { model: "seed-audio-1.0", prompt: <voice prompt> } }                                  # $3
+] }                                                                   → created[0..3].id = T1 H1 S1 V1
+```
 
 Command sequences for the three canvas types. All ids are placeholders — take real ones from the
 command output (`wji --json canvas add … | jq -r .id`) and `bind` them at once. `SD` below is

package/skill/short-drama/reference/operations-cli.md

@@ -36,6 +36,7 @@ The `wji` skill governs auth, confirmations and spending. The calls this skill m
 | preflight | `wji auth whoami --json`, `wji profile wallet` |
 | workspace | `wji ws create "<title>" -r <ratio>` → `wji ws use <id>` |
 | datasets | `wji dataset new … --app <appId>`, `wji fs set <id> --merge` (never `--content`), `--add-images` (never `--images` on an existing node) |
+| reads | `wji fs get <id> --json` is the `standard` summary; `--detail full` whenever you need the whole `content` (`--merge` reads full for you) |
 | canvases | `wji canvas create <name>` · `wji canvas add <kind> -c <cv> …` · `wji canvas connect <a> <b>` · `wji canvas get <node>` · `wji canvas gen <node> [--yes --wait]` · `wji canvas rm` |
 | assets | `wji asset download <id> -o <dir>` — **look at what you generated** before building on it |
 | history | `wji history get <id> --wait` |

package/skill/short-drama/reference/operations-wji.md

@@ -43,9 +43,9 @@ write a whole document at a time rather than field by field.
 
 | Purpose | Tool |
 | --- | --- |
-| workspace | `workspace_search`, `workspace_get`, `workspace_create`, `workspace_add_app` |
+| workspace | `workspace_get { id }` for the workspace the chat is in, `workspace_create`, `workspace_add_app`; `workspace_search` **only with `limit`** (≤ 10) and a `keyword` — without them it returns every workspace the user can see. Both default to `detail: 'standard'`; `detail: 'full'` only when you need `settings` |
 | semantic folders | `resolve_dataset_folder { id, key: 'story' \| 'character' \| 'location' \| 'prop' \| 'shot' }` |
-| datasets | `fsnode_create_file { parent, name, dataset: true, datasetType, description, content, tags }`, `fsnode_update`, `fsnode_upsert_segment` |
+| datasets | `fsnode_create_file { parent, name, dataset: true, datasetType, description, content, tags }`, `fsnode_update`, `fsnode_upsert_segment`; `fsnode_get { id, detail: 'full' }` before replacing a `content` (the default `standard` read is a summary with `truncated: true`, and writing it back is rejected) |
 | assets | `asset_get`, `asset_check_status`, `asset_create_from_url` |
 | canvases | the `canvas_*` tools below |
 
@@ -59,16 +59,21 @@ substitute:
 | `canvas-recipes.md` shows | call |
 | --- | --- |
 | `wji canvas create <name>` | `canvas_create { workspace, name }` → canvas id |
-| `wji canvas add <kind> -c CV -n "<name>" --at x,y …` | `canvas_create_node { canvas, kind, name, position: {x, y}, … }` |
+| `wji canvas add <kind> -c CV -n "<name>" --at x,y …` | `canvas_create_node { canvas, kind, name, position: {x, y}, … }` — one node |
+| a whole row of `wji canvas add …` lines | `canvas_create_nodes { canvas, nodes: [ … ] }` — up to 60 nodes in one call, each item the fields of `canvas_create_node` without `canvas`; `"$i"` in `fromNodeIds` / `nextTo` is item i of the same batch (0-based, must come earlier). Built in order; on a failure the result has `failedAt` and the earlier nodes stay |
 | `--prompt-file /tmp/x.txt` / `-p "<prompt>"` | `generate: { prompt, model, ratio, resolution, duration }` on `canvas_create_node` |
 | `--asset <id>` (a display node) | `assetId` on `canvas_create_node` |
 | `--from A B C` | `fromNodeIds: ['A','B','C']` — **the array order is the reference order** |
 | `wji canvas connect <a> <b>` | `canvas_connect_nodes { canvas, fromId, toId }` |
-| `wji canvas get <node>` | `canvas_get_node { canvas, id }` — references, label, status, asset |
+| `wji canvas get <node>` | `canvas_get_node { canvas, id }` — references, label, status, asset; `detail: 'full'` for the whole `generate` / `text` before editing them |
 | `wji canvas gen <node>` (cost preview) | `canvas_generate { canvas, nodeIds, estimateOnly: true }` |
 | `wji canvas gen <node> --yes --wait` | `canvas_generate { canvas, nodeIds, wait: true }` |
 | `wji canvas rm` | `canvas_delete_nodes { canvas, ids }` |
 
+Build each row with **one** `canvas_create_nodes` call (title, headshot, sheet `fromNodeIds: ["$1"]`,
+voice `fromNodeIds: ["$1"]`), not four `canvas_create_node` calls — see the batch example at the top
+of `canvas-recipes.md`.
+
 Reference labels (`@image1`, `@audio1` …) are numbered per type in connection order, exactly as the
 canvas UI numbers them. After connecting, call `canvas_get_node` and check the labels match what the
 prompt names **before** generating — a mislabelled reference is a wasted generation.
@@ -77,6 +82,24 @@ prompt names **before** generating — a mislabelled reference is a wasted gener
 first, tell the user the cost, and only generate for real once they say yes. The `wji` skill's
 spending policy applies here in full.
 
+## Steps and context
+
+**A turn is capped at 40 steps, not 40 tool calls** (an Agent can set its own cap). One step is one
+model call; every tool call you emit in the same step runs together and counts once. So emit
+independent calls together — all the `short_drama_render` / `fsnode_create_file` of a stage in one
+step, the five `resolve_dataset_folder` calls in one step — and write a whole document per
+`short_drama_put` rather than field by field. When two steps are left you get a system note: stop
+calling tools, report what was written (with ids) and what is still open; the stream ends at the cap
+without letting you reply.
+
+**Tool results stay in the context for the rest of the turn.** Read what you need, once: `ai_list_models`
+once per project with `features: 'image'` (it is large); `fsnode_get` on the one dataset you need
+instead of `fsnode_children` on a folder of them; `short_drama_get { section }` for one branch rather
+than the whole project; never `workspace_search` without `limit`. Every list / get tool takes
+`detail: 'brief' | 'standard' | 'full'` and defaults to `standard` (text clipped to 200 chars, media
+as `{ id, url, status }`, `content` summarised); ask for `brief` when you only need ids and for `full`
+only when you need the complete `content` / `form` / `settings`.
+
 **In a canvas chat** (the chat panel beside an open canvas) the browser supplies its own `canvas_*`
 tools, which always act on the canvas the user is looking at and take no `canvas` argument. A short
 drama needs several canvases, so do that work in a workspace chat; in a canvas chat, say so.

package/skill/short-drama/reference/stage-storyboard.md

@@ -345,6 +345,12 @@ segment is rejected, retry, then trim — do not go hunting for a forbidden word
 To bisect anyway, use a scratch video node at `-d 2`, 480P: free when rejected, ~30 credits when it
 passes, and sample each fragment several times because one pass proves nothing.
 
+**Last resort: the uncensored twin.** `wan-3.0-ref-uncensored` (MuleRouter, no green-net) takes the
+same prompt and the same 10 images + 5 videos + 5 audios, at ~1.3× the price; note that it bills the
+reference-video seconds as well as the output. Switch a stuck segment to it only with the
+Producer's approval, and only after retry-then-trim has failed. `short-drama.mjs` does not know it
+as a mode, so set it as the node's model directly.
+
 ## Sheets mode — no storyboard images (the default)
 
 `params.references: sheets` drops stage 5's image generation entirely: the video node references

package/skill/wji/SKILL.md

@@ -9,6 +9,12 @@ description: Drive the WJI AI platform from the terminal with the `wji` CLI —
 `--json`, so prefer `--json` piped through `jq` when you need to read a value,
 and the human table output when you are showing the user a result.
 
+`--json` prints the **`standard`** detail level: ids, names, status, media urls,
+long text clipped to 200 chars and `content` reduced to a summary marked
+`truncated: true`. Add `--detail full` whenever you need the whole `content`,
+`form` or `settings` (always before a read-modify-write), and `--detail brief`
+when you only want ids. `WJI_DETAIL=full` sets it for a whole session.
+
 ## Before anything else
 
 ```bash
@@ -94,7 +100,7 @@ wji ws fs                                  # whole workspace tree
 wji ws fs --app <appId>                    # one app's tree
 wji fs tree <nodeId> --depth 2
 wji fs ls <folderId>
-wji fs get <nodeId> --json | jq .content
+wji fs get <nodeId> --json --detail full | jq .content      # --detail full: the summary is not the content
 
 wji fs mkdir <parentId> characters --nickname 角色
 wji dataset new <folderId> "Ada" -t character -d "a tired detective"
@@ -211,6 +217,25 @@ balanced default; **Seedance 2.0 Fast / MiniMax H3 Max** for drafts, tests and
 large batches. The ranking is a guide — quote the real number from
 `wji gen cost` / `wji canvas gen` before spending.
 
+**Uncensored (無審核) models.** Use these only when the user asks for
+uncensored output or a censored model refused the content. They carry the
+`uncensored` tag in `wji models list --json`, and their names end in
+`-uncensored`. The Wan 3.0 family has a Ref and a first/last-frame variant of
+each tier, like the censored Wan 3.0.
+
+| Job | Model (`name`) | Inputs |
+| --- | --- | --- |
+| Video, Ref | `wan-3.0-ref-uncensored`, `wan-3.0-prime-ref-uncensored` (480p–1080p); `wan-3.0-pro-ref-uncensored`, `wan-3.0-prime-pro-ref-uncensored` (1080p / 2k / 4k) | ≤ 10 images + ≤ 5 videos + ≤ 5 audios, freely mixed (video/audio ≤ 15 s total) |
+| Video, first/last frame | `wan-3.0-uncensored`, `wan-3.0-prime-uncensored`, `wan-3.0-pro-uncensored`, `wan-3.0-prime-pro-uncensored` | text only, or start and/or end image; 2–30 s |
+| Image → video | `wan-2.7-i2v-uncensored` (720p/1080p, 2–15 s; optional 1 driving audio for lip-sync via `--ref-audio`), `wan-2.2-i2v-uncensored` (cheapest; 480p/720p, 5 or 8 s, optional end frame) | start image |
+| Animate a character | `wan-animate-uncensored` (`--set mode=animate\|replace`) | exactly 1 image + 1 video; output is as long as the video |
+| Text → image | `z-image-uncensored` (long edge ≤ 1536), `z-image-pro-uncensored` (≤ 2560, `--set long_edge=`) | prompt + ratio |
+| Edit an image | `qwen-image-edit-uncensored` | 1–3 images: the **first** is the image to edit |
+| Face / head swap | `face-swap-uncensored`, `head-swap-uncensored` | exactly 2 images, **order matters**: 1st = target picture, 2nd = the face / head to put on it |
+| Video upscale | `flashvsr-uncensored` (`--set resolution=720p\|1080p\|2k\|4k`) | 1 MP4 ≤ 120 s; billed per input second |
+
+"Prime" variants are faster and cost more; "Pro" variants output 1080p–4K.
+
 ### Limits (per account)
 
 | Limit | Value | When exceeded |
@@ -248,7 +273,7 @@ headshot and sheet as image references and the voice as an audio reference to
 a Ref model.
 
 ```bash
-wji fs get <datasetId> --scope full --json | jq '{images: [.images[]? | {id, type}], icon, primaryAudio}'
+wji fs get <datasetId> --json --detail full | jq '{images: [.images[]? | {id, type}], icon, primaryAudio}'
 wji fs set <datasetId> --add-images <headshot> <sheet> <voice> --icon <headshot> --set primaryAudio=<voice>
 ```
 
@@ -549,6 +574,9 @@ wji org list && wji org use <orgId>
 - **Lists are paginated.** `--limit` is capped at 100; `--limit -1` returns at
   most 500 on most endpoints. Page with `--page` instead of assuming you got
   everything.
+- **Lists are trimmed.** `--json` is the `standard` level; read `content`,
+  `form` or `settings` with `--detail full`, and never write back a `content`
+  that carries `truncated: true`.
 - **Report failures honestly.** A failed generation surfaces as a non-zero exit
   with the provider's message — pass it on rather than retrying silently.
 

package/skill/wji/reference/commands.md

@@ -10,7 +10,8 @@ Global flags (accepted before any subcommand):
 | `--org <orgId>` | organization context (`X-Org-Id`) |
 | `--no-org` | force personal context for this call |
 | `--locale <locale>` | response language: `cht`, `chs`, `en` |
-| `--json` | print the raw API response instead of tables |
+| `--json` | print JSON instead of tables (`standard` detail unless `--detail` is given) |
+| `--detail <level>` | `brief` / `standard` / `full` for list and get reads; `full` is the raw API response. Env `WJI_DETAIL` |
 
 Value conventions: `@file` reads a file, `-` reads stdin, `--set key=value`
 repeats and nests on dots, references are `assetId[:label[:weight]]`.
@@ -64,8 +65,8 @@ switch endpoint.
 
 | Command | API |
 | --- | --- |
-| `ws list [-k keyword] [-s all\|me\|shared\|favorite] [--page] [--limit]` | `GET /workspace/search` — `--limit` max 100, `-1` returns at most 500 |
-| `ws get [id]` | `GET /workspace/list/:id` |
+| `ws list [-k keyword] [-s all\|me\|shared\|favorite] [--page] [--limit]` | `GET /workspace/search` — `--limit` max 100, `-1` returns at most 500; sends `detail` |
+| `ws get [id]` | `GET /workspace/list/:id` — sends `detail` (`settings` and full members need `--detail full`) |
 | `ws use <id>` | stores the default workspace locally |
 | `ws create <name> [-d] [-r ratio] [-l lang] [-t type] [-a app...] [--no-apps]` | `POST /workspace/create` — without `-a` the workspace gets the default template `dataset datasetimagegeneration canvas`; `--no-apps` creates it empty (the API itself adds nothing) |
 | `ws update [id] [-n] [-d] [-r] [-l] [--set]` | `PUT /workspace/list/:id` |
@@ -96,10 +97,10 @@ Restriction from the backend: `Dataset`, `Draw`, `DatasetImageGeneration` and
 
 | Command | API |
 | --- | --- |
-| `fs root [key] [-d depth]` | `GET /fsnode/root[/:key]` — key defaults to your drive; pass a workspace id for its root |
-| `fs ls <id> [--limit] [--scope]` | `GET /fsnode/list/:id/children` |
-| `fs tree <id> [-d depth]` | `GET /fsnode/list/:id/tree` |
-| `fs get <id> [--scope]` | `GET /fsnode/list/:id` (comma-separated ids allowed) |
+| `fs root [key] [-d depth]` | `GET /fsnode/root[/:key]` — key defaults to your drive; pass a workspace id for its root; sends `detail` |
+| `fs ls <id> [--limit] [--scope]` | `GET /fsnode/list/:id/children` — sends `detail`; at `standard` each `content` is a summary |
+| `fs tree <id> [-d depth]` | `GET /fsnode/list/:id/tree` — sends `detail` |
+| `fs get <id> [--scope]` | `GET /fsnode/list/:id` (comma-separated ids allowed) — sends `detail`; `--detail full` for the whole `content` |
 | `fs path <id>` | `GET /fsnode/list/:id/path` |
 | `fs mkdir <parent> <name> [--nickname] [--content]` | `POST /fsnode/create` type=folder |
 | `fs touch <parent> <name> [--mimetype] [--asset] [--content]` | `POST /fsnode/create` type=file |
@@ -118,7 +119,7 @@ characters, nicknames at 200, and `fs batch` at 100 items per call.
 | Command | Notes |
 | --- | --- |
 | `dataset new <parent> <name> [-t type] [-d description] [--images] [--nickname]` | creates an fsnode with mimetype `workspace/dataset` |
-| `dataset list <folderId>` | dataset nodes in a folder |
+| `dataset list <folderId>` | dataset nodes in a folder (sends `detail`) |
 | `dataset get <key>` | `GET /dataset/list/:key` (vector-store record) |
 | `dataset rm <key> [-y]` | `DELETE /dataset/list/:key` |
 
@@ -150,6 +151,11 @@ Model parameters worth knowing (`--set`, see `wji models get`):
 `gpt-image-2.5-*` `background=transparent` returns a PNG with alpha;
 `bytedance-seedream-5-pro` `layer_decomposition=true` splits one reference
 image into separate PNG layer assets (exactly 1 reference, `size=1K|2K`).
+`face-swap-uncensored` / `head-swap-uncensored` take exactly 2 references in
+order (target picture, then the face / head); `qwen-image-edit-uncensored`
+edits the first reference; `z-image-*-uncensored` `long_edge=<px>`;
+`wan-animate-uncensored` `mode=animate|replace`; `flashvsr-uncensored`
+`resolution=720p|1080p|2k|4k`.
 
 Uploads of `.html`, `.xhtml`, `.svg`, `.js` and `.xml` are stored as
 `application/octet-stream` with `Content-Disposition: attachment`.
@@ -171,7 +177,7 @@ updates live.
 | `canvas copy [nodeIds...] --to <canvasIds...> [-c] [--selected] [--at x,y] [--same-position] [-y]` | the canvas's own copy-paste: new nodes (no position, `generate.historyId/pendingAssetId` dropped, finished asset shared via `file`), edges among them re-created oldest first so `@image1…` numbering holds, color tags kept and a missing label carried to the target. Edges from nodes outside the copy are left out. Default placement: right of what is already on the target |
 | `canvas nodes [-c] [-k kind] [-n regex] [--tag tags…\|--untagged]` | `GET /fsnode/list/:canvasId/children?limit=-1` + `POST /assets/check-status`. `-n` matches the node name as a case-insensitive regex (`/re/flags` to set flags yourself). `--tag` takes a label (`C01`, case-insensitive), a color (`red`) or a color id (`rose`); several values match any. Filters combine (AND) |
 | `canvas tags [-c] [-a]` | the canvas's color tags: color, label, node count (`-a` also unused, unlabelled colors) |
-| `canvas get <nodeId> [-c]` | same load; one node with references (`@image1 ← id`) and frame slots |
+| `canvas get <nodeId> [-c]` | same load; one node with references (`@image1 ← id`) and frame slots. Canvas commands always load the full canvas; `--detail` trims only the JSON they print (`standard` clips `text` / `generate.prompt` and drops `generate.values`) |
 | `canvas edges [-c] [--node]` | the `canvas/edge` children |
 | `canvas add <kind> [-c] [-n] [-t\|--text-file] [--plain] [--size w,h] [--asset] [--dataset] [-p\|--prompt-file] [-m] [-r] [--resolution] [-d] [--set] [--from ids…] [--at x,y]` | `POST /fsnode/create` (`canvas/node/<kind>`), then one `canvas/edge` per `--from`. Kinds: text, title, comment, image, video, audio, dataset. `add dataset --dataset <fsnodeId>` writes `content {datasetId, datasetName, datasetType, datasetParentName, description}` from the dataset node (must be `workspace/dataset`); it takes no `--from`. Text kinds are Markdown on the web; `--plain` turns every single line break into a Markdown hard break (`"  \n"`, fenced code untouched), and without it the CLI warns when a single break would be joined. `--size` writes `content.width/height` |
 | `canvas set <nodeId> [-c] [-n] [-t\|--text-file] [--plain] [--move x,y] [--size w,h] [-p] [-m] [-r] [--resolution] [-d] [--set]` | read → merge → `PATCH /fsnode/list/:id` with `contentPatch` of only the top-level keys that changed, so a concurrent browser edit of another key survives (falls back to a whole-content write on a backend without `contentPatch`) |
@@ -320,7 +326,7 @@ parameters are range-checked against the model's `min`/`max`.
 ## history
 
 `history list [-w] [--mode image|video|audio] [--fsnode] [--scope] [--scope-id] [--tags] [--bookmarked]` →
-`GET /ai/assets/history/search`
+`GET /ai/assets/history/search` (sends `detail`; `standard` clips `prompt` and summarises `form`)
 
 `history get <id> [--wait] [--timeout] [--interval]` ·
 `history bookmark <id> [--off]` · `history rm <id> [-y]` ·
@@ -329,12 +335,15 @@ parameters are range-checked against the model's `min`/`max`.
 ## models
 
 `models list [-f feature...] [-w] [-k keyword] [--all]` →
-`GET /ai/model/list/:features`
+`GET /ai/model/list/:features` (sends `detail`; at `standard` the `form` keeps
+only ratios, batch, reference caps and `other` options — `--detail full` for the
+whole schema)
 
 The endpoint matches with `features.some(...)`, so an empty feature list returns
 nothing; with no `-f` the CLI asks for every feature instead.
 
-The response is a curated view — no `id`, `rate`, `tags` or `protocol` — and it
+The response is a curated view — no `id`, `rate` or `protocol` (`tags` is
+included; uncensored models carry `uncensored`) — and it
 is de-duplicated by **`nickname`**, which is therefore the unique selector.
 `name` is not unique (`seedance-2.0` exists twice under different providers).
 Pass the `MODEL` column (the nickname) to `-m`.
@@ -467,6 +476,12 @@ Pass `null` to clear a nullable field. Password minimum is 6 characters.
   asset carrying `error` is also a failure.
 - Some GETs are cached per user for 10s, keyed on the full URL including the
   query string.
+- Workspace, fsnode, model and history reads accept `?detail=brief|standard|full`.
+  The API defaults to `full` (the website relies on it); the CLI sends the
+  `--detail` value, or `standard` under `--json`. `standard` clips long text to
+  200 chars, turns media into `{id, url, thumbnail, status, …}` and reduces an
+  fsnode `content` to a summary carrying `truncated: true`; never PATCH such a
+  summary back.
 - Paginated endpoints return `{ data, pagination: { total, page, limit, next,
   hasNext, hasPrev, totalPages } }`. An explicit `limit` is capped at **100**.
   `limit: -1` returns everything only on endpoints that opt in (`fs ls` does);