@wji.ai/cli 0.1.0 → 0.1.1

package/dist/commands/gen.js

@@ -2,7 +2,6 @@ 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';
-const PENDING = 0;
 const READY = 1;
 const CANCELLED = -1;
 /** `--ref abc123`, `--ref abc123:hero`, `--ref abc123:hero:0.6` */
@@ -81,22 +80,9 @@ export function reportHistory(history, assets) {
     ]);
 }
 async function submit(client, kind, body, opts) {
-    const path = opts.history
-        ? `/ai/assets/history/${kind}/generations`
-        : `/ai/assets/${kind}/generations`;
-    const result = await client.post(path, body);
-    if (!opts.history) {
-        // Raw mode returns Asset[] directly; there is no history to poll.
-        return render(result, (assets) => {
-            if (!Array.isArray(assets))
-                return detail(Object.entries(assets || {}));
-            table(assets, [
-                { header: 'assetId', value: (a) => a.id },
-                { header: 'state', value: (a) => (a.status === PENDING ? 'pending' : 'ready') },
-                { header: 'url', value: (a) => a.url },
-            ]);
-        });
-    }
+    // Always the history endpoint: the raw one silently drops fsnode, scope,
+    // scopeId and tags, and returns no id to poll with.
+    const result = await client.post(`/ai/assets/history/${kind}/generations`, body);
     if (!opts.wait) {
         if (isJsonMode())
             return printJson(result);
@@ -121,14 +107,13 @@ function withCommonOptions(cmd) {
         .option('-p, --prompt <text>', 'prompt text (@file / - for stdin)')
         .option('-n, --n <count>', 'number of outputs', '1')
         .option('-w, --workspace <id>', 'workspace to bill and file the result under')
-        .option('--fsnode <id>', 'attach the result to an fsnode')
+        .option('--fsnode <id>', 'file the history entry under an fsnode (does not add the asset to its images)')
         .option('--scope <scope>', 'history scope, e.g. workspace | canvas')
         .option('--scope-id <id>', 'history scope id')
         .option('-r, --ratio <ratio>', 'aspect ratio, e.g. 16:9')
         .option('--tags <tag...>', 'tags for the history entry')
         .option('--values <json>', 'model-specific form values (@file / - supported)')
         .option('--set <key=value...>', 'model-specific form values as key=value')
-        .option('--no-history', 'call the raw endpoint and return assets instead of a history')
         .option('--wait', 'block until the task finishes')
         .option('--timeout <seconds>', 'wait timeout', '900')
         .option('--interval <seconds>', 'poll interval', '5');

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { ApiError } from './core/client.js';
 import { color, setJsonMode } from './core/output.js';
@@ -15,7 +16,9 @@ import { profileCommand } from './commands/profile.js';
 import { presetCommand } from './commands/preset.js';
 import { skillCommand } from './commands/skill.js';
 import { canvasCommand } from './commands/canvas.js';
-const VERSION = '0.1.0';
+// Read from package.json so `wji --version` cannot drift from the published
+// version — the skill compares the two to detect a stale install.
+const VERSION = createRequire(import.meta.url)('../package.json').version;
 const program = new Command();
 program
     .name('wji')

package/package.json

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

package/skill/wji/SKILL.md

@@ -15,6 +15,18 @@ and the human table output when you are showing the user a result.
 wji auth whoami --json      # confirms endpoint, credential, org context
 ```
 
+- **Check for a CLI update first.** The skill documents the newest commands, so
+  an old binary fails in confusing ways:
+
+  ```bash
+  wji --version && npm view @wji.ai/cli version
+  ```
+
+  If the installed version is lower, tell the user to run
+  `npm i -g @wji.ai/cli@latest` (or `pnpm add -g` / `yarn global add`) before
+  continuing. A dev checkout linked into PATH updates with `pnpm build`
+  instead. If the registry check fails (offline, proxy), carry on — don't
+  block the task on it.
 - `wji: command not found`: the CLI is not on PATH. From the `wji-cli` repo,
   `npm run build`, then link it where the user can write without sudo —
   `ln -s "$PWD/dist/index.js" ~/.local/bin/wji` (if `~/.local/bin` is on
@@ -28,6 +40,9 @@ wji auth whoami --json      # confirms endpoint, credential, org context
 - `wji config show` reveals which endpoint and profile are active. A local
   backend is `wji config set endpoint http://localhost:3002` — `:3000` is the
   web frontend, not the API.
+- **Scan the user's message for `-auto`.** It is not a CLI flag — it is the
+  user telling you to generate everything this request needs without stopping
+  to confirm the spend. See *Rules* for what it does and does not waive.
 - **Running several `wji` commands in parallel? Prefer an API key**
   (`WJI_API_KEY`, or `wji auth key create <name> --save`). A JWT login rotates
   its refresh token, and the server revokes *every* session if a refresh token
@@ -115,11 +130,19 @@ wji gen video -m <modelName> -p "slow pan" -d 5 --start-image <assetId> --wait -
 wji gen audio -m <modelName> -p "rain on a tin roof" --wait
 ```
 
+- **Check the spending policy in *Rules* before you submit:** a single image
+  just runs; video, audio and anything with `-n` above 1 need a yes in the
+  chat first — unless the user's message carried `-auto`.
 - References are `assetId[:label[:weight]]`: `--ref 65f0…:hero:0.6`. Reference
   *assets*, not file paths — upload first with `wji asset upload`.
 - Model-specific parameters go through `--set` (`--set quality=high`); read the
   valid keys from `wji models get`.
-- `--fsnode <id>` files the result onto a node; `--tags` labels the history.
+- `--fsnode <id>` files the *history entry* under a node — it does **not** add
+  the asset to that node's `images`. Recover them later with
+  `wji history list --fsnode <id>`. To make a generated image part of a dataset
+  you must attach it yourself, and `fs set --images` replaces the whole array:
+  read the current ids first, then write old + new together.
+- `--tags` labels the history entry.
 - Video can take minutes. Without `--wait` you get a history id back:
   `wji history get <id> --wait` resumes polling, and `--timeout` is in seconds.
 - On timeout the task is usually still running — re-poll rather than
@@ -142,6 +165,18 @@ confirm with `wji models list --feature <image|video>` and `wji models get`.
 and big changes such as character sheets; `gpt-image-2.5-flare` for edits that
 keep the composition), **Nano Banana 2** or **Nano Banana Pro**.
 
+Two image jobs have one right model each:
+
+- **Transparent background** (logos, cut-outs, overlays, sprites) → GPT Image
+  2.5 with `--set background=transparent`; the result comes back as PNG with
+  alpha. `opaque` forces a filled background, `auto` lets the model decide.
+- **Split a picture into layers** (subject separated from background, for
+  compositing) → `bytedance-seedream-5-pro` with
+  `--set layer_decomposition=true`. It needs **exactly one** reference image,
+  a size tier (`--set size=1K|2K`, not pixel dimensions), and returns several
+  PNG layers as separate assets. On a canvas, run it in the browser's layer
+  editor instead — a CLI generate node keeps only one asset per node.
+
 **Video — reference models over first/last-frame models.** A family usually
 has both:
 
@@ -379,12 +414,34 @@ wji org list && wji org use <orgId>
   `--tags`, and the update commands' tag options, replace the whole value.
   Read the current value first, and check with the user before replacing
   anything they did not ask to change.
-- **Generation costs credits.** Run `wji gen cost` first for anything large
-  (high `-n`, long video), show the user the number, and get agreement before
-  submitting a batch. `wji canvas gen` prints its exact cost and refuses
-  without `--yes`: run it once without `--yes` to get the number, tell the
-  user, and pass `--yes` only after they agree. Creating or editing a generate
-  node (`canvas add` / `canvas set`) costs nothing.
+- **Generation costs credits — one image just runs; video and batches ask
+  first.** This is the user's standing policy. Follow it without asking them
+  to restate it:
+
+  | About to run | Do this |
+  | --- | --- |
+  | **One image** — `gen image` with `-n 1`, or `canvas gen` on an image node | **Go ahead.** Pass `--yes`, then report the `credits` line from the result. |
+  | **Any video or audio** | **Ask first.** Get the number, tell the user, wait for a yes. |
+  | **More than one generation in one step** — `-n 2` or higher, several nodes, a storyboard fan-out, an A×B matrix | **Ask first, with the total** — not the per-item price. |
+
+  Splitting a batch does not make it single: what needs approval is the total
+  you are about to spend in this step, however many commands it takes.
+
+  To get the number before asking, both of these are free: `wji gen cost -t
+  video -m <model> -d 8`, or run `wji canvas gen <nodeId>` *without* `--yes` —
+  it refuses to run and the error names the exact credits.
+
+  **`-auto` in the user's message overrides the table.** Generate everything
+  that request needs without asking — video and batches included — and report
+  the total actually charged when you are done. It covers that request and the
+  follow-ups continuing it; when the user moves to a different task, the table
+  above applies again. `-auto` never waives the confirmations for *destructive*
+  commands above, only the spending ones.
+
+  Creating or editing a generate node (`canvas add` / `canvas set`) costs
+  nothing, and neither does `gen cost`. Actual spend is in the result's
+  `credits` field (`history.chargedCredits`), so quote that rather than the
+  estimate once a job has finished.
 - **Never invent ids.** Look up workspace, node, asset and model ids with the
   list commands; ids are Mongo ObjectIds, not names.
 - **Stay inside the generation queue.** See *Limits* above — batch to the cap

package/skill/wji/reference/canvas-recipes.md

@@ -110,6 +110,18 @@ its defaults; check with `wji canvas get <node>` and tell the user what changed.
 
 > "Go ahead and generate it."
 
+**An image node just runs** (see the spending policy in SKILL.md *Rules*):
+
+```bash
+wji canvas gen <node> --yes --wait
+```
+
+Report the `credits` line from the result so the user sees what it actually
+cost.
+
+**A video or audio node needs a yes first** — so does any batch of nodes, and
+`-auto` in the user's message waives both:
+
 ```bash
 wji canvas gen <node>                       # prints the cost and refuses (no terminal)
 ```
@@ -147,8 +159,10 @@ Never resubmit a node whose status is `generating` — that charges twice.
    wji canvas add video -n "Shot 2" --from <char1> <char2> -m <model> -r 16:9 -d 5 -p "…shot 2…"
    ```
 
-4. Total the cost (`wji canvas gen <node>` for each, without `--yes`) before
-   offering to generate them all.
+4. Total the cost (`wji canvas gen <node>` for each, without `--yes`) and get a
+   yes on that total before generating any of them. A fan-out is a batch, so
+   this applies even when every node is an image — unless the request carried
+   `-auto`, in which case generate them all and report the total charged.
 
 ## 6. Fix which image is `@image1`
 

package/skill/wji/reference/commands.md

@@ -142,6 +142,11 @@ Semantic dataset folders created with the Dataset app: `story`, `character`,
 
 Asset states: `0` pending, `1` ready, `-1` cancelled.
 
+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`).
+
 Uploads of `.html`, `.xhtml`, `.svg`, `.js` and `.xml` are stored as
 `application/octet-stream` with `Content-Disposition: attachment`.
 
@@ -200,7 +205,7 @@ viewport, url}` on toggle (`takeover: true`), on selection change and every
 
 Shared flags: `-m/--model` (required), `-p/--prompt`, `-n/--n`, `-w/--workspace`,
 `--fsnode`, `--scope`, `--scope-id`, `-r/--ratio`, `--tags`, `--values`,
-`--set`, `--no-history`, `--wait`, `--timeout` (seconds, default 900),
+`--set`, `--wait`, `--timeout` (seconds, default 900),
 `--interval` (seconds, default 5).
 
 | Command | Extra flags | API |
@@ -210,8 +215,11 @@ Shared flags: `-m/--model` (required), `-p/--prompt`, `-n/--n`, `-w/--workspace`
 | `gen audio` | `-d/--duration`, `--ref-audio` | `POST /ai/assets/history/audio/generations` |
 | `gen cost -t <type> -m <model>` | `-n`, `-p`, `-d`, `-r`, `--refs`, `--values` | `POST /ai/assets/preComputeCost` |
 
-`--no-history` calls `/ai/assets/<type>/generations`, which returns assets
-directly and cannot be polled by history id.
+Every generation goes through the history endpoint — there is no raw mode. The
+backend also exposes `/ai/assets/<type>/generations`, which skips the history
+record, but the CLI never calls it: without a history there is no id to poll,
+and `fsnode`, `scope`, `scopeId` and `tags` are silently dropped (they are
+written only inside `if (toHistory)`).
 
 Admission limits, per user and API key (changing IP does not reset them):