@wji.ai/cli 0.6.0 → 0.7.0

package/README.md

@@ -102,8 +102,8 @@ wji --no-org ws list                 # one-off personal call
 | `wji asset` | upload, import from URL, search, status, download, summary |
 | `wji canvas` | Infinite Canvas: linked canvas + selection, nodes, references, generate nodes, submit, owners, color tags, copy between canvases |
 | `wji class` | teach with a workspace: roster, one canvas per student, copy nodes to every student, progress, collect results |
-| `wji npc` | NPC City NPCs you own: profile, publish, work history (jobs), soul, character document, transfers |
-| `wji backreel` | Backreel posts: drafts, publish, cast and crew credits (NPCs included) |
+| `wji npc` | NPC City NPCs you own: profile, publish, work history (jobs), soul, character document, transfers; memories, live readiness, stage documents |
+| `wji backreel` | Backreel posts: drafts, publish, images per slot, episodes on VOD, crowdfunding and donations, enquiries, cast and crew credits (NPCs included) |
 | `wji gen` | `image` / `video` / `audio` generation plus `cost` estimation |
 | `wji history` | generation history: search, poll, bookmark, download |
 | `wji models` | list models and their form parameters |
@@ -210,7 +210,11 @@ wji npc publish @mika
 
 wji backreel create "Harbour" -d @synopsis.txt --cover <assetId>
 wji backreel credit add <postId> --npc @mika --role "飾 阿明" --job appearance
+wji backreel image poster.png --slot portrait --post <postId>   # size check + upload + set
+wji backreel episode add <postId> E01.mp4 -t "第一集"            # VOD upload
+wji backreel check <postId>
 wji backreel publish <postId>
+wji backreel enquiry list --unread
 ```
 
 Creating NPCs needs NPC City spawn permission on your account. Admin actions
@@ -313,6 +317,19 @@ cp -r "$(npm root -g)/@wji.ai/cli/skill/social-media" ~/.claude/skills/social-me
 Install it the same way (`cp -r skill/short-drama ~/.claude/skills/short-drama`)
 next to `wji`; `node skill/short-drama/scripts/selftest.mjs` runs its self-test.
 
+`skill/backreel/` is a creator's skill for Backreel: create and publish a
+work, prepare images at the right size per slot (`wji br image`), upload and
+maintain episodes on VOD, run a crowdfunding campaign and donation tiers, and
+answer enquiries. Install it the same way
+(`cp -r skill/backreel ~/.claude/skills/backreel`).
+
+`skill/npc-character/` teaches an agent to write an NPC City character that
+feels like a person — want / need / contradiction, memories as scenes, a voice
+the reply model can imitate, protocols, on-camera habits — and its live
+stages, placing each word where the live runtime actually reads it, then
+applying them with `wji npc doc` / `memory` / `stage`. Install it the same way
+(`cp -r skill/npc-character ~/.claude/skills/npc-character`).
+
 `skill/wji-classroom/` is a teacher's skill on top of `wji`: set up a class
 workspace, invite students, give each a canvas, hand out prompts and starter
 nodes, and check or collect their work. Install it the same way

package/dist/commands/agent.js

@@ -15,6 +15,21 @@ function skillRefLabel(ref) {
         return String(ref);
     return ref.kind === 'system' ? `system:${ref.key}` : `user:${ref.id}`;
 }
+/** Backend DEFAULT_MAX_STEPS / MAX_STEPS_LIMIT (src/ai/_/constant.ts). */
+const DEFAULT_MAX_STEPS = 40;
+const MAX_STEPS_LIMIT = 200;
+/** `--max-steps`: an integer in range, or "default" to clear back to the site default. */
+function parseMaxSteps(value) {
+    if (value === undefined)
+        return undefined;
+    if (['default', 'none', 'null'].includes(value.trim().toLowerCase()))
+        return null;
+    const n = Number(value);
+    if (!Number.isInteger(n) || n < 1 || n > MAX_STEPS_LIMIT) {
+        throw new Error(`--max-steps must be an integer from 1 to ${MAX_STEPS_LIMIT} (or "default")`);
+    }
+    return n;
+}
 export function agentCommand(globals) {
     const agent = new Command('agent').description('Manage AI agents');
     agent
@@ -59,7 +74,7 @@ export function agentCommand(globals) {
     });
     agent
         .command('get <id>')
-        .description('Show an agent (instructions included when you own it)')
+        .description('Show an agent (private agents: creator only; instructions only when you own it)')
         .action(async (id) => {
         const client = new WjiClient(globals());
         const a = await client.get(`/ai/agent/list/${id}`);
@@ -72,6 +87,7 @@ export function agentCommand(globals) {
             ['category', a.category],
             ['tags', (a.tags || []).join(', ')],
             ['greeting', a.greeting],
+            ['maxSteps', a.maxSteps ?? color.dim(`default (${DEFAULT_MAX_STEPS})`)],
             ['creator', a.creator?.name || a.creator?.id || a.creator],
             ['organization', a.organization?.id || a.organization || 'personal'],
             ['skills', (a.skills || []).map(skillRefLabel).join(', ')],
@@ -80,7 +96,7 @@ export function agentCommand(globals) {
     });
     agent
         .command('create <name>')
-        .description('Create an agent')
+        .description('Create an agent (needs the agent-create permission on your account)')
         .requiredOption('-d, --description <text>', 'short description')
         .option('-i, --instructions <text>', 'system prompt (@file / - supported)')
         .option('-m, --model <name>', 'backing model')
@@ -89,7 +105,8 @@ export function agentCommand(globals) {
         .option('-t, --tag <tag...>', 'tags')
         .option('--greeting <text>', 'opening message')
         .option('--skill <ref...>', 'attach skills: system:<key> or user:<skillId>')
-        .option('--set <key=value...>', 'arbitrary field')
+        .option('--max-steps <n>', `model calls allowed per chat turn, 1-${MAX_STEPS_LIMIT} (default ${DEFAULT_MAX_STEPS})`)
+        .option('--set <key=value...>', 'arbitrary field (admin-only fields are dropped by the server)')
         .action(async (name, opts) => {
         const client = new WjiClient(globals());
         const created = await client.post('/ai/agent/create', {
@@ -102,13 +119,14 @@ export function agentCommand(globals) {
             tags: opts.tag,
             greeting: opts.greeting,
             skills: opts.skill?.length ? opts.skill.map(parseSkillRef) : undefined,
+            maxSteps: parseMaxSteps(opts.maxSteps),
             ...parseKeyValues(opts.set),
         });
         render(created, (a) => success(`Created agent ${a.name} (${a.id})`));
     });
     agent
         .command('update <id>')
-        .description('Update an agent')
+        .description('Update an agent (creator only)')
         .option('-n, --name <name>', 'new name')
         .option('-d, --description <text>', 'new description')
         .option('-i, --instructions <text>', 'new system prompt (@file / - supported)')
@@ -117,7 +135,8 @@ export function agentCommand(globals) {
         .option('-c, --category <name>', 'category')
         .option('-t, --tag <tag...>', 'replace tags')
         .option('--greeting <text>', 'opening message')
-        .option('--set <key=value...>', 'arbitrary field')
+        .option('--max-steps <n>', `model calls allowed per chat turn, 1-${MAX_STEPS_LIMIT}; "default" clears it`)
+        .option('--set <key=value...>', 'arbitrary field (admin-only fields are dropped by the server)')
         .action(async (id, opts) => {
         const client = new WjiClient(globals());
         const updated = await client.put(`/ai/agent/list/${id}`, {
@@ -129,6 +148,7 @@ export function agentCommand(globals) {
             category: opts.category,
             tags: opts.tag,
             greeting: opts.greeting,
+            maxSteps: parseMaxSteps(opts.maxSteps),
             ...parseKeyValues(opts.set),
         });
         render(updated, () => success(`Updated ${id}`));
@@ -147,7 +167,7 @@ export function agentCommand(globals) {
     });
     agent
         .command('files <id>')
-        .description('List files attached to an agent')
+        .description('List files attached to an agent (creator only)')
         .action(async (id) => {
         const client = new WjiClient(globals());
         const files = await client.get(`/ai/agent/list/${id}/files`);
@@ -236,7 +256,7 @@ export function agentCommand(globals) {
     });
     agent
         .command('versions <id>')
-        .description('List an agent\'s version history')
+        .description('List an agent\'s version history (creator only — snapshots hold instructions)')
         .action(async (id) => {
         const client = new WjiClient(globals());
         const versions = await client.get(`/ai/agent/list/${id}/versions`);
@@ -251,7 +271,7 @@ export function agentCommand(globals) {
     });
     agent
         .command('restore <id> <versionId>')
-        .description('Restore an agent to a previous version')
+        .description('Restore an agent to a previous version (creator only)')
         .action(async (id, versionId) => {
         const client = new WjiClient(globals());
         const result = await client.post(`/ai/agent/list/${id}/versions/${versionId}/restore`);

package/dist/commands/backreel-enquiry.js

@@ -0,0 +1,171 @@
+import { writeFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { Command } from 'commander';
+import { backreelClient, oneOf } from '../core/backreel.js';
+import { color, detail, info, render, relativeTime, success, table, truncate } from '../core/output.js';
+import { readValue } from '../core/prompt.js';
+const ENQ = '/backreel/enquiry';
+const TYPES = ['collaboration', 'new_project', 'investment', 'licensing', 'access_request', 'general'];
+const STATUSES = ['new', 'in_discussion', 'accepted', 'declined', 'archived', 'withdrawn'];
+/** What the recipient (post owner) may set; the sender may only withdraw. */
+const SETTABLE = ['in_discussion', 'accepted', 'declined', 'archived', 'withdrawn'];
+const MAX_ATTACHMENTS = 5;
+const MESSAGE_MAX = 4000;
+const person = (p) => (p ? `${p.name || p.id}${p.verifiedKinds?.length ? color.dim(` ✓${p.verifiedKinds.join(',')}`) : ''}` : color.dim('system'));
+/** Enquiry attachments are private Backreel files (purpose=enquiry: documents and images ≤20 MB). */
+async function uploadAttachments(client, files = []) {
+    if (files.length > MAX_ATTACHMENTS)
+        throw new Error(`At most ${MAX_ATTACHMENTS} attachments per message`);
+    const ids = [];
+    for (const file of files) {
+        info(color.dim(`Uploading ${basename(file)}…`));
+        const uploaded = await client.upload('/backreel/file/upload?purpose=enquiry', file, {});
+        ids.push(uploaded.id);
+    }
+    return ids;
+}
+function printSummaryTable(rows) {
+    table(rows, [
+        { header: 'id', value: (e) => e.id },
+        { header: '', value: (e) => (e.unread ? color.yellow('●') : '') },
+        { header: 'type', value: (e) => e.type },
+        { header: 'status', value: (e) => e.status + (e.archived && e.status !== 'archived' ? color.dim(' (archived)') : '') },
+        { header: 'from', value: (e) => truncate(e.side === 'sender' ? `→ ${e.recipient?.name}` : e.sender?.name, 20) },
+        { header: 'post', value: (e) => truncate(e.post?.title, 20) },
+        { header: 'last', value: (e) => truncate(e.lastMessagePreview || e.subject, 36) },
+        { header: 'when', value: (e) => relativeTime(e.lastMessageAt) },
+    ]);
+}
+function printEnquiry(e, messages) {
+    const extra = [];
+    if (e.projectInvite) {
+        const p = e.projectInvite;
+        const budget = p.budgetMin || p.budgetMax ? `${p.budgetMin ?? '?'}–${p.budgetMax ?? '?'} ${p.currency || ''}` : '';
+        extra.push(['project', [p.projectType, p.title, budget, p.location, p.roleNeeded].filter(Boolean).join(' · ')]);
+        if (p.timelineStart || p.timelineEnd)
+            extra.push(['timeline', `${p.timelineStart ?? '?'} → ${p.timelineEnd ?? '?'}`]);
+    }
+    if (e.licensing)
+        extra.push(['licensing', [e.licensing.territory, e.licensing.media, e.licensing.term].filter(Boolean).join(' · ')]);
+    if (e.investment)
+        extra.push(['investment', `${e.investment.ticketSize ?? '?'} ${e.investment.currency || ''}`]);
+    if (e.accessPurpose)
+        extra.push(['access purpose', e.accessPurpose]);
+    const c = e.contact || {};
+    detail([
+        ['id', e.id],
+        ['type', e.type],
+        ['status', e.status + (e.archived && e.status !== 'archived' ? ' (archived)' : '')],
+        ['subject', e.subject],
+        ['post', `${e.post?.title} (${e.post?.id})`],
+        ['from', person(e.sender)],
+        ['to', `${person(e.recipient)} (${e.recipientRole})`],
+        ['contact', [c.name, c.email, c.phone, c.company].filter(Boolean).join(' · ')],
+        ...extra,
+        ['sender access', e.senderAccess ? `${e.senderAccess.partnerState}${e.senderAccess.supporter ? ', supporter' : ''}` : undefined],
+        ['can', Object.entries(e.permissions || {}).filter(([, v]) => v).map(([k]) => k).join(', ')],
+        ['attachments', (e.attachments || []).map((f) => `${f.name} (${f.id})`).join(', ')],
+        ['created', e.createdAt],
+    ]);
+    process.stdout.write('\n');
+    for (const m of messages) {
+        const who = m.kind === 'system' ? color.dim('— system') : color.bold(person(m.sender));
+        process.stdout.write(`${who} ${color.dim(relativeTime(m.createdAt) ?? '')}\n`);
+        if (m.body)
+            process.stdout.write(`${m.body}\n`);
+        for (const f of m.attachments || [])
+            process.stdout.write(color.dim(`  📎 ${f.name} (${f.id})\n`));
+        process.stdout.write('\n');
+    }
+}
+export function enquiryCommand(globals) {
+    const enq = new Command('enquiry')
+        .aliases(['enquiries', 'enq'])
+        .description('Enquiries about your posts: read, reply, accept / decline, grant partner access');
+    enq.command('list', { isDefault: true })
+        .description('Your inbox (received) or what you sent, newest activity first')
+        .option('--box <box>', 'received | sent', 'received')
+        .option('--post <postId>', 'only this post')
+        .option('--status <status>', STATUSES.join(' | '))
+        .option('--type <type>', TYPES.join(' | '))
+        .option('--unread', 'only unread')
+        .option('--archived', 'show the archive instead of the inbox')
+        .option('--page <n>', 'page number', '1')
+        .option('--limit <n>', 'page size', '20')
+        .action(async (opts) => {
+        const client = backreelClient(globals);
+        const result = await client.get(`${ENQ}/search`, {
+            box: oneOf(opts.box, ['received', 'sent'], '--box'),
+            post: opts.post,
+            status: opts.status ? oneOf(opts.status, STATUSES, '--status') : undefined,
+            type: opts.type ? oneOf(opts.type, TYPES, '--type') : undefined,
+            unread: opts.unread ? 'true' : undefined,
+            archived: opts.archived ? 'true' : undefined,
+            page: Number(opts.page),
+            limit: Number(opts.limit),
+        });
+        render(result, (r) => {
+            printSummaryTable(r?.data || []);
+            const p = r?.pagination;
+            if (p)
+                info(color.dim(`${p.total} total · page ${p.page}${p.hasNext ? ` · more: --page ${p.page + 1}` : ''}`));
+        });
+    });
+    enq.command('unread')
+        .description('Unread counts')
+        .action(async () => {
+        const client = backreelClient(globals);
+        const counts = await client.get(`${ENQ}/unread-count`);
+        render(counts, (c) => detail([['received', c.received], ['sent', c.sent], ['total', c.total]]));
+    });
+    enq.command('get <id>')
+        .description('Show an enquiry and its whole thread (marks it read)')
+        .action(async (id) => {
+        const client = backreelClient(globals);
+        const e = await client.getFresh(`${ENQ}/list/${id}`);
+        const messages = await client.getFresh(`${ENQ}/list/${id}/messages`);
+        render({ ...e, messages }, () => printEnquiry(e, messages || []));
+    });
+    enq.command('reply <id> <message>')
+        .description(`Reply in the thread (≤${MESSAGE_MAX} chars; @file / - supported). The other side gets an in-app notice and, at most every 30 min, an email`)
+        .option('-a, --attach <file...>', `attach files (≤${MAX_ATTACHMENTS}; documents / images ≤20 MB)`)
+        .action(async (id, message, opts) => {
+        const client = backreelClient(globals);
+        const body = (await readValue(message)).trim();
+        if (!body && !opts.attach?.length)
+            throw new Error('Empty reply');
+        if (body.length > MESSAGE_MAX)
+            throw new Error(`Reply is ${body.length} chars; the limit is ${MESSAGE_MAX}`);
+        const attachments = await uploadAttachments(client, opts.attach);
+        const sent = await client.post(`${ENQ}/list/${id}/messages`, { body, attachments: attachments.length ? attachments : undefined });
+        render(sent, () => success('Reply sent'));
+    });
+    enq.command('status <id> <status>')
+        .description(`Move an enquiry: ${SETTABLE.join(' | ')} (accepting an access_request grants partner access)`)
+        .action(async (id, status) => {
+        const client = backreelClient(globals);
+        const updated = await client.post(`${ENQ}/list/${id}/status`, { status: oneOf(status, SETTABLE, 'status') });
+        render(updated, (e) => success(`Enquiry ${id} is now ${e.status}`));
+    });
+    enq.command('grant <id>')
+        .description('Give the sender partner access to the post (creator only; also accepts an open enquiry)')
+        .action(async (id) => {
+        const client = backreelClient(globals);
+        const updated = await client.post(`${ENQ}/list/${id}/grant`);
+        render(updated, (e) => success(`Granted partner access to ${e.sender?.name || 'the sender'} — status ${e.status}`));
+    });
+    enq.command('download <fileId>')
+        .description('Download an attachment (private file; the signed link lasts 60 s)')
+        .option('-o, --out <path>', 'output path (default: the original file name)')
+        .action(async (fileId, opts) => {
+        const client = backreelClient(globals);
+        const link = await client.get(`/backreel/file/${fileId}/download`);
+        const res = await fetch(link.url);
+        if (!res.ok)
+            throw new Error(`Download failed: HTTP ${res.status}`);
+        const out = opts.out || basename(link.name || fileId);
+        await writeFile(out, Buffer.from(await res.arrayBuffer()));
+        render({ ...link, path: out }, () => success(`Saved ${out}`));
+    });
+    return enq;
+}

package/dist/commands/backreel-episode.js

@@ -0,0 +1,243 @@
+import { stat } from 'node:fs/promises';
+import { basename, extname } from 'node:path';
+import { Command } from 'commander';
+import { ApiError } from '../core/client.js';
+import { POSTS, TIERS, backreelClient, episodeIndex, idOf, loadPost, oneOf } from '../core/backreel.js';
+import { color, info, render, success, table, truncate, warn } from '../core/output.js';
+import { confirm } from '../core/prompt.js';
+import { uploadToVod } from '../core/vod.js';
+const MAX_EPISODES = 30;
+const VIDEO_EXTS = ['.mp4', '.mov', '.m4v', '.webm'];
+/** /assets/v2/upload cap for video — only the --legacy path goes through it. */
+const ASSET_VIDEO_MAX_BYTES = 200 * 1024 * 1024;
+/** The fields the update DTO takes back; vodStatus / poster / duration are server-owned. */
+function toDto(e, order) {
+    const base = { title: e.title, order, tier: e.tier || 'public' };
+    return e.vodVid ? { ...base, vodVid: e.vodVid } : { ...base, video: idOf(e.video) };
+}
+async function loadEpisodes(client, postId) {
+    const post = await loadPost(client, postId);
+    if (post.kind !== 'showcase') {
+        throw new Error(`"${post.title}" is a ${post.kind} post — only showcase posts have episodes`);
+    }
+    const episodes = [...(post.episodes || [])]
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+        .map((e, i) => toDto(e, i));
+    return { post, episodes };
+}
+/** The server re-sorts by `order`, re-indexes, and re-checks every vodVid with VOD. */
+function saveEpisodes(client, postId, episodes) {
+    if (episodes.length > MAX_EPISODES)
+        throw new Error(`A post can have at most ${MAX_EPISODES} episodes`);
+    return client.put(`${POSTS}/list/${postId}`, { episodes: episodes.map((e, i) => ({ ...e, order: i })) });
+}
+/**
+ * Turn `[file] / --vid / --asset` into an episode source. A local file goes to
+ * Backreel's VOD space by default (signed, expiring play URLs); `--legacy`
+ * uploads it as a plain WJI asset with a permanent public URL instead.
+ */
+async function resolveSource(client, opts, postId, file) {
+    const given = [file, opts.vid, opts.asset].filter(Boolean).length;
+    if (given > 1)
+        throw new Error('Give one video source: a file, --vid or --asset');
+    if (opts.vid)
+        return { vodVid: opts.vid };
+    if (opts.asset)
+        return { video: opts.asset };
+    if (!file)
+        return null;
+    const ext = extname(file).toLowerCase();
+    if (!VIDEO_EXTS.includes(ext))
+        throw new Error(`${basename(file)}: episodes must be ${VIDEO_EXTS.join(' / ')}`);
+    const size = (await stat(file)).size;
+    if (opts.legacy) {
+        if (size > ASSET_VIDEO_MAX_BYTES)
+            throw new Error(`${basename(file)} is over 200 MB — drop --legacy to upload it to VOD`);
+        info(color.dim(`Uploading ${basename(file)} as a WJI asset…`));
+        const asset = await client.upload('/assets/v2/upload', file, {});
+        return { video: asset.id };
+    }
+    const token = await client.post('/backreel/vod/upload-token');
+    const vid = await uploadToVod(token, file, (step) => info(color.dim(`VOD: ${step}…`)));
+    // claim checks the space, tags it with the post, publishes the media and starts transcoding.
+    const claimed = await client.post('/backreel/vod/claim', { vid, postId, title: opts.title?.slice(0, 128) });
+    info(color.dim(`VOD ${vid}: ${claimed?.status ?? 'claimed'}`));
+    return { vodVid: vid };
+}
+function printEpisodes(post) {
+    const rows = [...(post.episodes || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    table(rows, [
+        { header: '#', value: (e) => (e.order ?? 0) + 1 },
+        { header: 'title', value: (e) => truncate(e.title, 32) },
+        { header: 'tier', value: (e) => e.tier },
+        { header: 'source', value: (e) => (e.vodVid ? `vod ${e.vodVid}` : e.video ? `asset ${idOf(e.video)}` : '-') },
+        { header: 'status', value: (e) => (e.vodVid ? e.vodStatus || '?' : e.video ? 'ready' : '') },
+        { header: 'duration', value: (e) => (e.durationSec ? `${Math.round(e.durationSec)}s` : '') },
+    ]);
+}
+const sourceOptions = (cmd) => cmd
+    .option('--vid <vid>', 'a Vid already in the Backreel VOD space')
+    .option('--asset <assetId>', 'an uploaded WJI video asset (legacy path, public URL)')
+    .option('--legacy', 'upload the file as a WJI asset (≤200 MB) instead of VOD');
+export function episodeCommand(globals) {
+    const ep = new Command('episode')
+        .aliases(['episodes', 'ep'])
+        .description('Episodes of a showcase post: upload, reorder, gate by tier, check transcoding');
+    ep.command('list <postId>', { isDefault: true })
+        .description('List the episodes with their tier, source and VOD status')
+        .action(async (postId) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        render(post.episodes || [], () => {
+            if (!(post.episodes || []).length)
+                return info(`"${post.title}" has no episodes yet`);
+            printEpisodes(post);
+        });
+    });
+    sourceOptions(ep.command('add <postId> [file]')
+        .description('Add an episode: upload a local video to VOD, or use --vid / --asset')
+        .requiredOption('-t, --title <title>', 'episode title')
+        .option('--tier <tier>', `who can watch: ${TIERS.join(' | ')}`, 'public')
+        .option('--at <n>', 'insert as episode n (default: last)')).action(async (postId, file, opts) => {
+        const client = backreelClient(globals);
+        const tier = oneOf(opts.tier, TIERS, '--tier');
+        const { post, episodes } = await loadEpisodes(client, postId);
+        if (episodes.length >= MAX_EPISODES)
+            throw new Error(`"${post.title}" already has ${MAX_EPISODES} episodes`);
+        const at = opts.at === undefined ? episodes.length : episodeIndex(opts.at, episodes.length + 1);
+        const source = await resolveSource(client, opts, postId, file);
+        if (!source)
+            throw new Error('Give the video: a file, --vid <vid> or --asset <assetId>');
+        episodes.splice(at, 0, { title: opts.title, order: at, tier, ...source });
+        const updated = await saveEpisodes(client, postId, episodes);
+        render(updated.episodes, () => {
+            success(`Added episode ${at + 1} "${opts.title}" to "${updated.title}"`);
+            printEpisodes(updated);
+            if ('vodVid' in source)
+                info(color.dim('VOD transcoding takes a few minutes — `wji backreel episode status` to check'));
+        });
+    });
+    sourceOptions(ep.command('set <postId> <n> [file]')
+        .description('Change episode n: title, tier, or replace its video')
+        .option('-t, --title <title>', 'new title')
+        .option('--tier <tier>', TIERS.join(' | '))).action(async (postId, n, file, opts) => {
+        const client = backreelClient(globals);
+        const { episodes } = await loadEpisodes(client, postId);
+        const i = episodeIndex(n, episodes.length);
+        const source = await resolveSource(client, { ...opts, title: opts.title || episodes[i].title }, postId, file);
+        if (!opts.title && !opts.tier && !source)
+            throw new Error('Nothing to change — pass --title, --tier or a new video');
+        const next = { title: opts.title || episodes[i].title, order: i, tier: opts.tier ? oneOf(opts.tier, TIERS, '--tier') : episodes[i].tier };
+        episodes[i] = source ? { ...next, ...source } : { ...episodes[i], ...next };
+        const updated = await saveEpisodes(client, postId, episodes);
+        render(updated.episodes, () => {
+            success(`Updated episode ${i + 1}`);
+            printEpisodes(updated);
+        });
+    });
+    ep.command('rm <postId> <n...>')
+        .description('Remove episodes (later ones move up)')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (postId, ns, opts) => {
+        const client = backreelClient(globals);
+        const { episodes } = await loadEpisodes(client, postId);
+        const drop = new Set(ns.map((n) => episodeIndex(n, episodes.length)));
+        const names = [...drop].sort((a, b) => a - b).map((i) => `${i + 1}. ${episodes[i].title}`).join(', ');
+        if (!(await confirm(`Remove ${names}?`, opts.yes)))
+            return info('Aborted');
+        const updated = await saveEpisodes(client, postId, episodes.filter((_, i) => !drop.has(i)));
+        render(updated.episodes, () => {
+            success(`Removed ${drop.size} episode(s)`);
+            printEpisodes(updated);
+        });
+    });
+    ep.command('move <postId> <from> <to>')
+        .description('Move episode <from> to position <to>')
+        .action(async (postId, from, to) => {
+        const client = backreelClient(globals);
+        const { episodes } = await loadEpisodes(client, postId);
+        const a = episodeIndex(from, episodes.length);
+        const b = episodeIndex(to, episodes.length);
+        const [moved] = episodes.splice(a, 1);
+        episodes.splice(b, 0, moved);
+        const updated = await saveEpisodes(client, postId, episodes);
+        render(updated.episodes, () => {
+            success(`Moved "${moved.title}" to episode ${b + 1}`);
+            printEpisodes(updated);
+        });
+    });
+    ep.command('tiers <postId>')
+        .description('Tier ladder: public up to episode N, members up to M, the rest at --rest')
+        .option('--public-to <n>', 'episodes 1..n are public', '0')
+        .option('--member-to <n>', 'then up to episode n for signed-in members')
+        .option('--rest <tier>', `everything after: ${TIERS.join(' | ')}`, 'supporter')
+        .action(async (postId, opts) => {
+        const client = backreelClient(globals);
+        const { episodes } = await loadEpisodes(client, postId);
+        const pub = Number(opts.publicTo);
+        const mem = opts.memberTo === undefined ? pub : Number(opts.memberTo);
+        if (!Number.isInteger(pub) || pub < 0 || !Number.isInteger(mem) || mem < pub) {
+            throw new Error('--public-to and --member-to are episode numbers, with --member-to ≥ --public-to');
+        }
+        const rest = oneOf(opts.rest, TIERS, '--rest');
+        episodes.forEach((e, i) => {
+            e.tier = i < pub ? 'public' : i < mem ? 'member' : rest;
+        });
+        const updated = await saveEpisodes(client, postId, episodes);
+        render(updated.episodes, () => {
+            success('Episode tiers updated');
+            printEpisodes(updated);
+        });
+    });
+    ep.command('status <postId>')
+        .description('Refresh VOD transcoding state (it only updates when someone asks to play)')
+        .action(async (postId) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        const results = [];
+        for (const e of [...(post.episodes || [])].sort((a, b) => (a.order ?? 0) - (b.order ?? 0))) {
+            const row = { n: (e.order ?? 0) + 1, title: e.title, source: e.vodVid ? 'vod' : 'asset', status: 'ready', duration: e.durationSec };
+            if (e.vodVid) {
+                try {
+                    const play = await client.get(`${POSTS}/list/${postId}/episodes/${e.order}/play`);
+                    row.duration = play.durationSec ?? row.duration;
+                }
+                catch (err) {
+                    if (err instanceof ApiError && err.status === 409)
+                        row.status = err.body?.status || 'processing';
+                    else
+                        row.status = `error: ${err.message}`;
+                }
+            }
+            results.push(row);
+        }
+        render(results, (rows) => {
+            if (!rows.length)
+                return info(`"${post.title}" has no episodes yet`);
+            table(rows, [
+                { header: '#', value: (r) => r.n },
+                { header: 'title', value: (r) => truncate(r.title, 32) },
+                { header: 'source', value: (r) => r.source },
+                { header: 'status', value: (r) => (r.status === 'ready' ? color.green('ready') : color.yellow(r.status)) },
+                { header: 'duration', value: (r) => (r.duration ? `${Math.round(r.duration)}s` : '') },
+            ]);
+            if (rows.some((r) => r.status === 'failed'))
+                warn('A failed transcode needs a new upload: `episode set <post> <n> <file>`');
+        });
+    });
+    ep.command('play <postId> <n>')
+        .description('Print a short-lived play URL for episode n (as the owner)')
+        .action(async (postId, n) => {
+        const client = backreelClient(globals);
+        const post = await loadPost(client, postId);
+        const i = episodeIndex(n, (post.episodes || []).length);
+        const order = [...post.episodes].sort((a, b) => (a.order ?? 0) - (b.order ?? 0))[i].order ?? i;
+        const play = await client.get(`${POSTS}/list/${postId}/episodes/${order}/play`);
+        render(play, (p) => {
+            process.stdout.write(`${p.url}\n`);
+            if (p.expiresAt)
+                info(color.dim(`expires ${p.expiresAt}`));
+        });
+    });
+    return ep;
+}