@wji.ai/cli 0.3.0 → 0.4.0

package/README.md

@@ -107,6 +107,7 @@ wji --no-org ws list                 # one-off personal call
 | `wji agent` | browse and manage AI agents |
 | `wji preset` | prompt presets: yours, public, workspace; fork and copy |
 | `wji skill` | agent skills: system list, push/pull SKILL.md bundles, import zip, update, rm |
+| `wji crew` | install crew packs (skills + agent seats) into Claude Code, Codex, OpenClaw, or export for Grok bot |
 | `wji profile` | account profile, password, wallet, login history |
 
 Run `wji <group> --help` for the full option list.
@@ -161,6 +162,7 @@ wji canvas status                                   # what is linked and selecte
 wji canvas add video --from <img1> <img2> -m seedance-2.0-fast-ref -r 16:9 -d 8 \
   -p "@image1 paddles across the lake while @image2 waits on the shore"
 wji canvas set <node> --resolution 720p --set seed=42
+wji canvas add text --text-file prompt.txt --plain --size 600,900   # text nodes are Markdown; --plain keeps line breaks
 wji canvas gen <node> --yes --wait                  # spends credits
 ```
 
@@ -249,3 +251,29 @@ stages are checked by `skill/short-drama/scripts/short-drama.mjs validate`,
 with the data stored as workspace datasets and the work laid out on canvases.
 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.
+
+## Crews (`wji crew`)
+
+A **crew pack** is a repository of Agent Skills plus agent seats (`crew.json` +
+`agents/<seat>.md`) — the multi-agent form of a pipeline. `wji crew install`
+puts one where each host discovers it, writing that host's agent format from
+the same persona files:
+
+```bash
+wji crew install short-drama --for claude        # ~/.claude/skills + ~/.claude/agents/<seat>.md
+wji crew install short-drama --for codex         # ~/.agents/skills + ~/.codex/agents/<seat>.toml
+wji crew install short-drama --for openclaw      # ~/.agents/skills + ~/.openclaw/workspaces/<crew>/<seat>/{AGENTS,SOUL}.md
+wji crew install short-drama --for grok          # ./<crew>-export.zip in the Grok bot import layout
+wji crew install short-drama --for all --dry-run # show the plan only
+wji crew install --from ../short-drama-crew --for claude --link   # symlink a local checkout
+wji crew status                                  # what was written, and whether it is still there
+wji crew uninstall short-drama-crew --for codex  # remove exactly the recorded paths
+wji crew check ./short-drama-crew                # validate a pack before publishing it
+```
+
+Known crews: `short-drama` ([ultra-instinct-ai/short-drama-crew](https://github.com/ultra-instinct-ai/short-drama-crew)).
+`--from` also takes a `.zip`, a `.tar.gz` or a URL; `--ref` picks a branch or tag;
+`--project <dir>` installs into a project instead of your home directory. The
+installer never edits `~/.openclaw/openclaw.json` — it writes a JSON5 fragment
+to merge — and it warns that the Codex `wji-operator` seat needs
+`[sandbox_workspace_write] network_access = true`.

package/dist/commands/canvas.js

@@ -46,6 +46,22 @@ const INITIAL_CANVAS_CONTENT = {
 const MEDIA_BASE = 250;
 const PLACE_GAP = 80;
 const PENDING = 0;
+/**
+ * The canvas's color tags (nodeColorTags.ts on the web). A node stores only
+ * `content.colorTag {colorId}`; the label is shared per color on the canvas
+ * folder as `content.colorTagNames {<colorId>: label}`. `alias` is the plain
+ * color name the tag reads as, so `--tag red` finds `rose`.
+ */
+const COLOR_TAGS = [
+    { id: 'rose', alias: 'red', hex: '#f43f5e' },
+    { id: 'orange', alias: 'orange', hex: '#f97316' },
+    { id: 'amber', alias: 'yellow', hex: '#eab308' },
+    { id: 'lime', alias: 'green', hex: '#84cc16' },
+    { id: 'teal', alias: 'teal', hex: '#14b8a6' },
+    { id: 'sky', alias: 'blue', hex: '#0ea5e9' },
+    { id: 'violet', alias: 'purple', hex: '#8b5cf6' },
+    { id: 'fuchsia', alias: 'pink', hex: '#d946ef' },
+];
 const idOf = (value) => value == null ? undefined : typeof value === 'string' ? value : value.id;
 function toList(result) {
     return Array.isArray(result) ? result : result?.data || [];
@@ -110,8 +126,62 @@ async function loadCanvas(client, canvasId) {
         edges,
         byId: new Map(nodes.map((n) => [n.id, n])),
         assets,
+        tagNames: parseTagNames(folder.content?.colorTagNames),
     };
 }
+// ── color tags ──────────────────────────────────────────────────────────────
+function parseTagNames(raw) {
+    const out = {};
+    if (!raw || typeof raw !== 'object')
+        return out;
+    for (const { id } of COLOR_TAGS) {
+        const value = raw[id];
+        if (typeof value === 'string' && value.trim())
+            out[id] = value.trim();
+    }
+    return out;
+}
+/** The node's tag with the canvas label (never the node's own legacy `name`, as on the web). */
+function tagOf(canvas, node) {
+    const colorId = node.content.colorTag?.colorId;
+    const tag = COLOR_TAGS.find((t) => t.id === colorId);
+    if (!tag)
+        return undefined;
+    return { color: tag.id, alias: tag.alias, hex: tag.hex, label: canvas.tagNames[tag.id] };
+}
+/**
+ * Colors a `--tag` value means: a color id (`rose`), its plain name (`red`),
+ * or a label (`C01`, case-insensitive), so several colors can match one label.
+ */
+function resolveTagFilter(canvas, values) {
+    const colors = new Set();
+    for (const value of values) {
+        const v = value.trim().toLowerCase();
+        const matched = COLOR_TAGS.filter((t) => t.id === v || t.alias === v || canvas.tagNames[t.id]?.toLowerCase() === v);
+        if (!matched.length) {
+            const known = COLOR_TAGS.map((t) => (canvas.tagNames[t.id] ? `${t.alias} "${canvas.tagNames[t.id]}"` : t.alias));
+            throw new Error(`No color tag "${value}" on canvas "${canvas.name}". Tags: ${known.join(', ')}`);
+        }
+        for (const t of matched)
+            colors.add(t.id);
+    }
+    return colors;
+}
+/** `C0[1-3]` is case-insensitive; `/C0[1-3]$/` keeps exactly the flags given. */
+function parseRegex(value, flag) {
+    const slashed = /^\/(.*)\/([a-z]*)$/s.exec(value);
+    try {
+        return slashed ? new RegExp(slashed[1], slashed[2].replace(/[gy]/g, '')) : new RegExp(value, 'i');
+    }
+    catch (err) {
+        throw new Error(`${flag}: invalid regex ${value} — ${err.message}`);
+    }
+}
+function tagText(tag) {
+    if (!tag)
+        return '';
+    return tag.label ? `${tag.alias} "${tag.label}"` : tag.alias;
+}
 /** The `canvases` folder of every InfiniteCanvas app in a workspace. */
 async function canvasesFolders(client, wsId) {
     const ws = await client.get(`/workspace/list/${wsId}`);
@@ -158,7 +228,9 @@ function describe(canvas, node) {
         id: node.id,
         kind: node.kind,
         name: node.name,
+        tag: tagOf(canvas, node),
         position: node.content.position,
+        size: Number(node.content.width) > 0 && Number(node.content.height) > 0 ? { width: Number(node.content.width), height: Number(node.content.height) } : undefined,
         mode: MEDIA_KINDS.has(node.kind) ? node.content.mode || 'display' : undefined,
         text: TEXT_KINDS.has(node.kind) ? node.content.text ?? '' : undefined,
         assetId: node.file,
@@ -270,6 +342,10 @@ function applyModelDefaults(model, kind, generate, opts) {
 // ── writes ──────────────────────────────────────────────────────────────────
 /** Short side 250, like the canvas; text-ish nodes use a typical card size. */
 function estimateSize(canvas, node) {
+    const w = Number(node.content.width);
+    const h = Number(node.content.height);
+    if (w > 0 && h > 0)
+        return { width: w, height: h };
     if (node.kind === 'dataset')
         return { width: 480, height: 220 };
     if (!MEDIA_KINDS.has(node.kind))
@@ -380,6 +456,7 @@ function nodeTable(rows) {
         { header: 'id', value: (n) => n.id },
         { header: 'kind', value: (n) => (n.mode === 'generate' ? `${n.kind}*` : n.kind) },
         { header: 'name', value: (n) => truncate(n.name, 20) },
+        { header: 'tag', value: (n) => truncate(tagText(n.tag), 16) },
         { header: 'refs', value: (n) => n.references.map((r) => r.label).join(',') },
         { header: 'summary', value: (n) => truncate(summary(n), 64) },
     ]);
@@ -390,7 +467,9 @@ function printNode(n) {
         ['id', n.id],
         ['kind', n.mode ? `${n.kind} (${n.mode})` : n.kind],
         ['name', n.name],
+        ['tag', n.tag && `${tagText(n.tag)} ${color.dim(n.tag.color)}`],
         ['position', n.position && `${Math.round(n.position.x)},${Math.round(n.position.y)}`],
+        ['size', n.size && `${n.size.width}×${n.size.height}`],
         ['text', n.text],
         ['dataset', n.dataset && `${n.dataset.type || 'dataset'} "${n.dataset.name || ''}" ${color.dim(n.dataset.id)}${n.dataset.folder ? ` in ${n.dataset.folder}` : ''}`],
         ['asset', n.assetId],
@@ -420,6 +499,46 @@ async function literalOrFile(value, file) {
         return undefined;
     return value === '-' ? readValue('-') : value;
 }
+/**
+ * Text, title and comment nodes are Markdown on the web (a single line break joins the lines into
+ * one paragraph). `--plain` keeps plain text as written: a line break becomes a Markdown hard break
+ * ("  \n"); blank lines stay paragraph breaks and fenced code blocks are left alone.
+ */
+export function plainToMarkdown(text) {
+    let fenced = false;
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    return lines
+        .map((line, i) => {
+        const fence = /^\s*(```|~~~)/.test(line);
+        if (fence)
+            fenced = !fenced;
+        const next = lines[i + 1];
+        const hard = !fence && !fenced && i < lines.length - 1 && line.trim() !== '' && next !== undefined && next.trim() !== '' && !/^\s*(```|~~~)/.test(next);
+        return hard ? `${line.replace(/\s+$/, '')}  ` : line;
+    })
+        .join('\n');
+}
+/** True when a single line break would be joined away by the web's Markdown rendering. */
+export function hasSoftBreaks(text) {
+    return /[^\s\n][ \t]?\n(?![ \t]*\n)[ \t]*\S/.test(text.replace(/\r\n?/g, '\n').replace(/ {2,}\n/g, '\n\n'));
+}
+async function nodeText(kind, opts) {
+    const text = await literalOrFile(opts.text, opts.textFile);
+    if (text === undefined)
+        return undefined;
+    if (opts.plain)
+        return plainToMarkdown(text);
+    if (TEXT_KINDS.has(kind) && hasSoftBreaks(text) && !isJsonMode()) {
+        warn('text nodes render as Markdown on the web — single line breaks join into one paragraph; pass --plain to keep them');
+    }
+    return text;
+}
+function parseSize(value) {
+    const [width, height] = value.split(/[,x×]/i).map((v) => Number(v.trim()));
+    if (!(width > 0 && height > 0))
+        throw new Error('--size must look like width,height (e.g. 600,900)');
+    return { width: Math.round(width), height: Math.round(height) };
+}
 function parsePoint(value, label) {
     const [x, y] = value.split(',').map((v) => Number(v.trim()));
     if (!Number.isFinite(x) || !Number.isFinite(y))
@@ -684,15 +803,53 @@ export function canvasCommand(globals) {
         .description('Nodes with references and a content summary (* = generate node)')
         .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
         .option('-k, --kind <kind>', 'only this kind')
+        .option('--tag <tags...>', 'only nodes with one of these color tags: label (C01), color (red) or id (rose)')
+        .option('--untagged', 'only nodes without a color tag')
+        .option('-n, --name <regex>', 'only nodes whose name matches this regex (case-insensitive; /re/flags for your own flags)')
         .action(async (opts) => {
+        if (opts.tag && opts.untagged)
+            throw new Error('Pass --tag or --untagged, not both');
+        const nameRe = opts.name !== undefined ? parseRegex(opts.name, '--name') : undefined;
         const c = client();
         const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
-        const rows = cv.nodes.filter((n) => !opts.kind || n.kind === opts.kind).map((n) => describe(cv, n));
+        const colors = opts.tag ? resolveTagFilter(cv, opts.tag) : undefined;
+        const rows = cv.nodes
+            .filter((n) => !opts.kind || n.kind === opts.kind)
+            .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 }, () => {
             info(color.dim(`${cv.name} (${cv.id}) · ${rows.length} node(s) · ${cv.edges.length} edge(s)`));
             nodeTable(rows);
         });
     });
+    canvas
+        .command('tags')
+        .description('The canvas color tags: color, label and how many nodes carry each')
+        .option('-c, --canvas <id>', 'canvas id (defaults to the linked canvas)')
+        .option('-a, --all', 'also colors no node uses and that have no label')
+        .action(async (opts) => {
+        const c = client();
+        const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
+        const rows = COLOR_TAGS.map((t) => ({
+            color: t.id,
+            alias: t.alias,
+            hex: t.hex,
+            label: cv.tagNames[t.id],
+            nodes: cv.nodes.filter((n) => n.content.colorTag?.colorId === t.id).length,
+        })).filter((r) => opts.all || r.nodes || r.label);
+        render({ canvas: { id: cv.id, name: cv.name }, tags: rows }, () => {
+            info(color.dim(`${cv.name} (${cv.id})`));
+            if (!rows.length)
+                return info('No color tags on this canvas (--all lists the colors)');
+            table(rows, [
+                { header: 'color', value: (r) => r.alias },
+                { header: 'id', value: (r) => color.dim(r.color) },
+                { header: 'label', value: (r) => r.label || '' },
+                { header: 'nodes', value: (r) => String(r.nodes) },
+            ]);
+        });
+    });
     canvas
         .command('get <nodeId>')
         .description('One node in full, with its references')
@@ -726,6 +883,8 @@ export function canvasCommand(globals) {
         .option('-n, --name <name>', 'node name')
         .option('-t, --text <text>', 'text for text/title/comment (- reads stdin)')
         .option('--text-file <path>', 'read the text from a file')
+        .option('--plain', 'text is plain, not Markdown: keep every line break (the web renders text nodes as Markdown)')
+        .option('--size <w,h>', 'node width and height in canvas pixels (e.g. 600,900)')
         .option('--asset <assetId>', 'show an existing asset (display node)')
         .option('--dataset <fsnodeId>', 'for `add dataset`: the workspace dataset node to show on the canvas')
         .option('--from <nodeIds...>', 'connect these nodes in as references, in order (@image1, @image2…)')
@@ -746,7 +905,7 @@ export function canvasCommand(globals) {
         };
         let model;
         if (TEXT_KINDS.has(kind)) {
-            const text = await literalOrFile(opts.text, opts.textFile);
+            const text = await nodeText(kind, opts);
             if (text === undefined)
                 throw new Error(`${kind} nodes need --text`);
             content.text = text;
@@ -792,6 +951,8 @@ export function canvasCommand(globals) {
                 content.generate = applyModelDefaults(model, kind, patch, { workspaceRatio: ws.aspectRatio, explicit });
             }
         }
+        if (opts.size)
+            Object.assign(content, parseSize(opts.size));
         if (opts.at)
             content.position = parsePoint(opts.at, '--at');
         else {
@@ -822,7 +983,9 @@ export function canvasCommand(globals) {
         .option('-n, --name <name>', 'rename')
         .option('-t, --text <text>', 'replace the text of a text/title/comment node (- reads stdin)')
         .option('--text-file <path>', 'read the text from a file')
-        .option('--move <x,y>', 'move to this position')).action(async (id, opts) => {
+        .option('--plain', 'text is plain, not Markdown: keep every line break')
+        .option('--move <x,y>', 'move to this position')
+        .option('--size <w,h>', 'resize: width and height in canvas pixels')).action(async (id, opts) => {
         const c = client();
         const cv = await loadCanvas(c, await resolveCanvasId(c, opts.canvas));
         const node = requireNode(cv, id);
@@ -831,7 +994,7 @@ export function canvasCommand(globals) {
         let changed = false;
         if (opts.name !== undefined)
             (body.name = opts.name), (changed = true);
-        const text = await literalOrFile(opts.text, opts.textFile);
+        const text = await nodeText(node.kind, opts);
         if (text !== undefined) {
             if (!TEXT_KINDS.has(node.kind))
                 throw new Error(`${node.kind} nodes have no text`);
@@ -840,6 +1003,8 @@ export function canvasCommand(globals) {
         }
         if (opts.move)
             (content.position = parsePoint(opts.move, '--move')), (changed = true);
+        if (opts.size)
+            Object.assign(content, parseSize(opts.size)), (changed = true);
         const { patch, explicit } = await generateOptions(opts);
         if (Object.keys(patch).length) {
             if (!MEDIA_KINDS.has(node.kind))

package/dist/commands/crew.js

@@ -0,0 +1,205 @@
+import { Command } from 'commander';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { confirm } from '../core/prompt.js';
+import { color, detail, info, isJsonMode, printJson, render, success, table, warn } from '../core/output.js';
+import { CREW_REGISTRY, TARGETS, applyOps, describeOp, fetchPack, findOpenclaw, grokZip, loadPackFromDir, pathState, planClaude, planCodex, planOpenclaw, readInstalled, relOrAbs, uninstallPaths, validatePack, writeInstalled, } from '../core/crew.js';
+/**
+ * `wji crew` — install a crew pack (skills + agent seats) into the hosts that
+ * run them: Claude Code, OpenAI Codex, OpenClaw, and the Grok bot platform
+ * (as an import zip). One pack, one command per host.
+ */
+function parseTargets(value) {
+    if (!value || value === 'all')
+        return ['claude', 'codex', 'openclaw', 'grok'];
+    const out = [];
+    for (const raw of value.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean)) {
+        if (!TARGETS.includes(raw))
+            throw new Error(`Unknown target "${raw}". Use: ${TARGETS.join(', ')} or all`);
+        out.push(raw);
+    }
+    return out;
+}
+function requireValid(pack) {
+    const errors = validatePack(pack);
+    if (errors.length)
+        throw new Error(`Pack ${pack.crew.name} is not valid:\n  - ${errors.join('\n  - ')}`);
+}
+export function crewCommand(_globals) {
+    const crew = new Command('crew').description('Install crew packs (skills + agent seats) into Claude Code, Codex, OpenClaw or a Grok bot export');
+    crew
+        .command('install [name]')
+        .description(`Install a crew for one or more hosts (known crews: ${Object.keys(CREW_REGISTRY).join(', ')})`)
+        .option('--for <targets>', 'comma-separated: claude, codex, openclaw, grok, or all', 'all')
+        .option('--from <source>', 'a local pack folder, a .zip / .tar.gz, or an http(s) URL instead of the registry')
+        .option('--ref <ref>', 'git branch or tag when fetching from the registry')
+        .option('--project <dir>', 'install into this project (.claude/, .agents/, .codex/, openclaw/) instead of your home directory')
+        .option('--link', 'symlink skills and Claude agents to a local --from folder instead of copying')
+        .option('--out <zip>', 'where to write the Grok export zip (default ./<crew>-export.zip)')
+        .option('--no-register', 'openclaw: only write the workspaces and config fragment; do not run `openclaw agents add`')
+        .option('--dry-run', 'print what would be written and stop')
+        .option('-y, --yes', 'skip the confirmation')
+        .action(async (name, opts) => {
+        const targets = parseTargets(opts.for);
+        const pack = await fetchPack(name || 'short-drama', { from: opts.from, ref: opts.ref });
+        requireValid(pack);
+        if (opts.link && (!opts.from || /^https?:/.test(opts.from) || !pack.root.startsWith(resolve(opts.from)))) {
+            throw new Error('--link needs a local --from <folder>');
+        }
+        const io = { project: opts.project, link: !!opts.link, out: opts.out };
+        const plans = {};
+        for (const t of targets) {
+            if (t === 'claude')
+                plans.claude = planClaude(pack, io);
+            if (t === 'codex')
+                plans.codex = planCodex(pack, io);
+            if (t === 'openclaw')
+                plans.openclaw = planOpenclaw(pack, io, { register: opts.register !== false });
+        }
+        // codex and openclaw share ~/.agents/skills — write each skill once
+        if (plans.codex && plans.openclaw) {
+            const seen = new Set(plans.codex.filter((o) => o.kind !== 'exec').map((o) => o.path));
+            plans.openclaw = plans.openclaw.filter((o) => o.kind === 'exec' || !seen.has(o.path));
+        }
+        const grokOut = targets.includes('grok') ? resolve(opts.out || `${pack.crew.name}-export.zip`) : undefined;
+        info(`${color.bold(pack.crew.title || pack.crew.name)} — ${Object.keys(pack.agents).length} seat(s), ${pack.skills.size} skill(s) from ${pack.source}${pack.ref ? ` @ ${pack.ref}` : ''}`);
+        for (const t of targets) {
+            info('');
+            info(color.bold(`[${t}]`));
+            if (t === 'grok')
+                info(`  zip   ${relOrAbs(grokOut)}`);
+            for (const op of plans[t] || [])
+                info(`  ${describeOp(op).replace(/^(\w+)/, (m) => color.dim(m))}`);
+        }
+        if (opts.dryRun)
+            return info(color.dim('\n--dry-run: nothing written'));
+        info('');
+        if (!(await confirm('Write these?', opts.yes)))
+            return info('Aborted');
+        const installed = readInstalled();
+        const record = installed[pack.crew.name] || { source: pack.source, ref: pack.ref, installedAt: '', targets: {} };
+        record.source = pack.source;
+        record.ref = pack.ref;
+        record.installedAt = new Date().toISOString();
+        const summary = {};
+        for (const t of targets) {
+            info(color.bold(`[${t}]`));
+            if (t === 'grok') {
+                const { zip, entries } = grokZip(pack);
+                mkdirSync(dirname(grokOut), { recursive: true });
+                writeFileSync(grokOut, zip);
+                info(`  ✓ ${entries} entries → ${relOrAbs(grokOut)}`);
+                record.targets.grok = { paths: [grokOut], notes: [] };
+                summary.grok = { zip: grokOut, entries };
+                continue;
+            }
+            const previous = record.targets[t]?.paths || [];
+            const result = applyOps(plans[t] || [], info);
+            // paths from an earlier install of this crew that this run did not touch are stale — drop them
+            const stale = previous.filter((p) => !result.paths.includes(p));
+            if (stale.length)
+                uninstallPaths(stale);
+            record.targets[t] = result;
+            summary[t] = { written: result.paths.length, notes: result.notes };
+        }
+        installed[pack.crew.name] = record;
+        writeInstalled(installed);
+        if (targets.includes('openclaw')) {
+            const frag = (record.targets.openclaw?.paths || []).find((p) => p.endsWith('openclaw.agents.json5'));
+            warn(`openclaw: merge ${frag} into ~/.openclaw/openclaw.json (skills allowlists, tools, subagents, channel bindings) — the CLI never rewrites that file.`);
+            if (!findOpenclaw())
+                info(color.dim('  openclaw binary not found; the agents were not registered — run `openclaw agents add <seat> --workspace <dir>` for each seat.'));
+        }
+        if (targets.includes('codex')) {
+            info(color.dim('codex: the wji-operator seat needs network — set [sandbox_workspace_write] network_access = true in ~/.codex/config.toml.'));
+        }
+        if (isJsonMode())
+            return printJson({ crew: pack.crew.name, targets: summary });
+        success(`Installed ${pack.crew.name} for ${targets.join(', ')}`);
+    });
+    crew
+        .command('status [name]')
+        .description('What `wji crew install` wrote, per host, and whether it is still there')
+        .action((name) => {
+        const installed = readInstalled();
+        const names = name ? [name] : Object.keys(installed);
+        const rows = [];
+        for (const n of names) {
+            const rec = installed[n];
+            if (!rec) {
+                warn(`${n}: not installed by wji crew`);
+                continue;
+            }
+            for (const [target, data] of Object.entries(rec.targets)) {
+                for (const p of data?.paths || [])
+                    rows.push({ crew: n, target, path: p, state: pathState(p) });
+            }
+        }
+        render({ installed, rows }, () => {
+            if (!rows.length)
+                return info('Nothing installed by `wji crew`. Try `wji crew install short-drama --for claude`.');
+            for (const n of names) {
+                const rec = installed[n];
+                if (!rec)
+                    continue;
+                detail([
+                    ['crew', n],
+                    ['source', `${rec.source}${rec.ref ? ` @ ${rec.ref}` : ''}`],
+                    ['installed', rec.installedAt],
+                ]);
+            }
+            info('');
+            table(rows, [
+                { header: 'target', value: (r) => r.target },
+                { header: '', value: (r) => (r.state === 'missing' ? color.red('✗') : r.state === 'link' ? color.dim('↗') : color.green('✓')) },
+                { header: 'path', value: (r) => relOrAbs(r.path) },
+            ]);
+        });
+    });
+    crew
+        .command('uninstall <name>')
+        .description('Remove what `wji crew install` wrote for a crew (only the recorded paths)')
+        .option('--for <targets>', 'comma-separated targets, default all recorded', 'all')
+        .option('-y, --yes', 'skip the confirmation')
+        .action(async (name, opts) => {
+        const installed = readInstalled();
+        const rec = installed[name];
+        if (!rec)
+            throw new Error(`${name} was not installed by wji crew`);
+        const targets = parseTargets(opts.for).filter((t) => rec.targets[t]);
+        const paths = targets.flatMap((t) => rec.targets[t]?.paths || []);
+        if (!paths.length)
+            return info('Nothing to remove');
+        for (const p of paths)
+            info(`  rm ${relOrAbs(p)}`);
+        if (!(await confirm(`Remove ${paths.length} path(s)?`, opts.yes)))
+            return info('Aborted');
+        uninstallPaths(paths);
+        for (const t of targets)
+            delete rec.targets[t];
+        if (!Object.keys(rec.targets).length)
+            delete installed[name];
+        writeInstalled(installed);
+        if (targets.includes('openclaw'))
+            warn('openclaw: remove the agents.entries / bindings you merged into ~/.openclaw/openclaw.json, and `openclaw agents delete <seat>` for each seat.');
+        success(`Removed ${paths.length} path(s)`);
+    });
+    crew
+        .command('check <dir>')
+        .description('Validate a local crew pack (crew.json, agents/*.md, skills/*/SKILL.md, links)')
+        .action((dir) => {
+        const pack = loadPackFromDir(dir);
+        const errors = validatePack(pack);
+        render({ crew: pack.crew.name, agents: Object.keys(pack.agents), skills: [...pack.skills.keys()], errors }, () => {
+            if (errors.length) {
+                for (const e of errors)
+                    info(`  ✗ ${e}`);
+                throw new Error(`${errors.length} problem(s) in ${dir}`);
+            }
+            success(`${pack.crew.name}: ${Object.keys(pack.agents).length} seat(s), ${pack.skills.size} skill(s), all links resolve`);
+        });
+        if (errors.length)
+            process.exitCode = 1;
+    });
+    return crew;
+}

package/dist/core/archive.js

@@ -0,0 +1,95 @@
+import { gunzipSync, inflateRawSync } from 'node:zlib';
+/**
+ * Minimal archive readers — enough to open a GitHub source tarball
+ * (`codeload.github.com/.../tar.gz/...`) and a plain zip, without a dependency.
+ * Both return forward-slash paths → file contents; directories are dropped.
+ */
+/** ustar / GNU tar, gzipped. Handles GNU long names (`L`) and skips pax headers. */
+export function readTarGz(buffer) {
+    const tar = gunzipSync(buffer);
+    const files = new Map();
+    let offset = 0;
+    let longName;
+    const field = (start, len) => tar.subarray(offset + start, offset + start + len).toString('utf8').replace(/\0.*$/s, '');
+    while (offset + 512 <= tar.length) {
+        const header = tar.subarray(offset, offset + 512);
+        if (header.every((b) => b === 0))
+            break;
+        const size = parseInt(field(124, 12).trim() || '0', 8);
+        const type = field(156, 1);
+        const prefix = field(345, 155);
+        let name = field(0, 100);
+        if (prefix)
+            name = `${prefix}/${name}`;
+        if (longName)
+            (name = longName), (longName = undefined);
+        const body = tar.subarray(offset + 512, offset + 512 + size);
+        offset += 512 + Math.ceil(size / 512) * 512;
+        if (type === 'L') {
+            longName = body.toString('utf8').replace(/\0.*$/s, '');
+            continue;
+        }
+        if (type === 'x' || type === 'g' || type === '5')
+            continue; // pax headers, directories
+        if (/(^|\/)\._[^/]*$/.test(name))
+            continue; // AppleDouble metadata from macOS tar
+        if (type === '0' || type === '' || type === '\0')
+            files.set(name, Buffer.from(body));
+    }
+    return files;
+}
+/** Zip with stored or deflated entries, read from the central directory. */
+export function readZip(buffer) {
+    const files = new Map();
+    // End of central directory record: signature 0x06054b50, search backwards (comment ≤ 64 KiB)
+    let eocd = -1;
+    for (let i = buffer.length - 22; i >= Math.max(0, buffer.length - 65558); i--) {
+        if (buffer.readUInt32LE(i) === 0x06054b50) {
+            eocd = i;
+            break;
+        }
+    }
+    if (eocd < 0)
+        throw new Error('Not a zip file (no central directory)');
+    const count = buffer.readUInt16LE(eocd + 10);
+    let p = buffer.readUInt32LE(eocd + 16);
+    for (let n = 0; n < count; n++) {
+        if (buffer.readUInt32LE(p) !== 0x02014b50)
+            throw new Error('Corrupt zip central directory');
+        const method = buffer.readUInt16LE(p + 10);
+        const compressed = buffer.readUInt32LE(p + 20);
+        const nameLen = buffer.readUInt16LE(p + 28);
+        const extraLen = buffer.readUInt16LE(p + 30);
+        const commentLen = buffer.readUInt16LE(p + 32);
+        const localOffset = buffer.readUInt32LE(p + 42);
+        const name = buffer.subarray(p + 46, p + 46 + nameLen).toString('utf8');
+        p += 46 + nameLen + extraLen + commentLen;
+        if (name.endsWith('/') || /(^|\/)\._[^/]*$/.test(name) || name.startsWith('__MACOSX/'))
+            continue;
+        // local header: 30 bytes + name + extra (the local extra length can differ from the central one)
+        const lNameLen = buffer.readUInt16LE(localOffset + 26);
+        const lExtraLen = buffer.readUInt16LE(localOffset + 28);
+        const start = localOffset + 30 + lNameLen + lExtraLen;
+        const data = buffer.subarray(start, start + compressed);
+        if (method === 0)
+            files.set(name, Buffer.from(data));
+        else if (method === 8)
+            files.set(name, inflateRawSync(data));
+        else
+            throw new Error(`Unsupported zip compression method ${method} for ${name}`);
+    }
+    return files;
+}
+/**
+ * Source archives wrap everything in one top-level folder (`repo-ref/…`,
+ * `short-drama-crew-export/…`). Strip it when every path shares it.
+ */
+export function stripCommonRoot(files) {
+    const roots = new Set([...files.keys()].map((p) => p.split('/')[0]));
+    if (roots.size !== 1 || ![...files.keys()].every((p) => p.includes('/')))
+        return files;
+    const out = new Map();
+    for (const [path, content] of files)
+        out.set(path.slice(path.indexOf('/') + 1), content);
+    return out;
+}

package/dist/core/crew.js

@@ -0,0 +1,546 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { configDir } from './config.js';
+import { createZip } from './zip.js';
+import { readTarGz, readZip, stripCommonRoot } from './archive.js';
+/**
+ * A crew pack is a folder (or archive of one) shaped like:
+ *
+ *   crew.json            roles, skill allowlists, capabilities, delegation, channels
+ *   agents/<slug>.md     one persona per seat: Claude-agent frontmatter + body
+ *   skills/<name>/…      Agent Skills (SKILL.md + reference/ + scripts/ …)
+ *   AGENTS.md            shared operating rules (optional)
+ *
+ * `wji crew install` copies the skills where each host discovers them and
+ * writes each host's agent format from the same persona files.
+ */
+export const TARGETS = ['claude', 'codex', 'openclaw', 'grok'];
+/** Where a named crew is fetched from when no --from is given. */
+export const CREW_REGISTRY = {
+    'short-drama': { repo: 'ultra-instinct-ai/short-drama-crew', defaultRef: 'main' },
+};
+// ── frontmatter ─────────────────────────────────────────────────────────────
+/** The YAML subset the persona files use: `key: value`, `key:` + `  - item` lists, `>-` folded blocks. */
+export function parseFrontmatter(raw) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(raw);
+    if (!m)
+        return { frontmatter: {}, body: raw };
+    const fm = {};
+    const lines = m[1].split(/\r?\n/);
+    let key;
+    let folded = false;
+    for (const line of lines) {
+        const top = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+        if (top && !/^\s/.test(line)) {
+            key = top[1];
+            const value = top[2].trim();
+            if (value === '>-' || value === '>' || value === '|' || value === '|-') {
+                fm[key] = '';
+                folded = true;
+            }
+            else if (value === '') {
+                fm[key] = [];
+                folded = false;
+            }
+            else {
+                fm[key] = value.replace(/^["'](.*)["']$/, '$1');
+                folded = false;
+            }
+            continue;
+        }
+        if (!key)
+            continue;
+        const item = /^\s+-\s+(.*)$/.exec(line);
+        if (item && Array.isArray(fm[key]))
+            fm[key].push(item[1].trim());
+        else if (folded && typeof fm[key] === 'string')
+            fm[key] = `${fm[key]}${fm[key] ? ' ' : ''}${line.trim()}`;
+    }
+    return { frontmatter: fm, body: raw.slice(m[0].length).replace(/^\s*\n/, '') };
+}
+const listOf = (v) => Array.isArray(v) ? v : typeof v === 'string' && v ? v.split(',').map((s) => s.trim()).filter(Boolean) : [];
+// ── loading ─────────────────────────────────────────────────────────────────
+function walk(dir, rel = '') {
+    const out = new Map();
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith('.') && entry.name !== '.sync-source')
+            continue;
+        const full = join(dir, entry.name);
+        const path = rel ? `${rel}/${entry.name}` : entry.name;
+        if (entry.isDirectory())
+            for (const [p, c] of walk(full, path))
+                out.set(p, c);
+        else if (entry.isFile())
+            out.set(path, readFileSync(full));
+    }
+    return out;
+}
+export function loadPackFromDir(dir, source = dir, ref) {
+    const root = resolve(dir);
+    const manifestPath = join(root, 'crew.json');
+    if (!existsSync(manifestPath))
+        throw new Error(`${dir} is not a crew pack (no crew.json)`);
+    const crew = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    const skillsDir = join(root, crew.skillsDir || 'skills');
+    const skills = new Map();
+    if (existsSync(skillsDir)) {
+        for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            skills.set(entry.name, walk(join(skillsDir, entry.name)));
+        }
+    }
+    const agents = {};
+    for (const [slug, spec] of Object.entries(crew.agents || {})) {
+        const file = join(root, spec.prompt);
+        if (!existsSync(file))
+            throw new Error(`crew.json: agent ${slug} points at missing ${spec.prompt}`);
+        const raw = readFileSync(file, 'utf8');
+        const { frontmatter, body } = parseFrontmatter(raw);
+        agents[slug] = { slug, frontmatter, body, raw };
+    }
+    const agentsMdPath = join(root, 'AGENTS.md');
+    return {
+        root,
+        crew,
+        agents,
+        skills,
+        agentsMd: existsSync(agentsMdPath) ? readFileSync(agentsMdPath, 'utf8') : undefined,
+        source,
+        ref,
+    };
+}
+export function crewCacheDir() {
+    return join(configDir(), 'crews');
+}
+function unpackTo(files, dir) {
+    rmSync(dir, { recursive: true, force: true });
+    for (const [path, content] of files) {
+        if (path.includes('..'))
+            continue;
+        const full = join(dir, path);
+        mkdirSync(dirname(full), { recursive: true });
+        writeFileSync(full, content);
+    }
+}
+/**
+ * Resolve `--from` (a folder, a .zip / .tar.gz file, or an http(s) URL) or a
+ * registry name into a loaded pack. Archives are unpacked into the cache.
+ */
+export async function fetchPack(nameOrFrom, opts = {}) {
+    const from = opts.from;
+    if (from && !/^https?:\/\//.test(from)) {
+        const path = resolve(from);
+        if (!existsSync(path))
+            throw new Error(`No such file or directory: ${from}`);
+        if (statSync(path).isDirectory())
+            return loadPackFromDir(path, path);
+        const buffer = readFileSync(path);
+        const files = stripCommonRoot(/\.zip$/i.test(path) ? readZip(buffer) : readTarGz(buffer));
+        const dir = join(crewCacheDir(), basename(path).replace(/\.(zip|tar\.gz|tgz)$/i, ''), 'local');
+        unpackTo(files, dir);
+        return loadPackFromDir(dir, path);
+    }
+    let url = from;
+    let ref = opts.ref;
+    let name = nameOrFrom;
+    if (!url) {
+        const entry = CREW_REGISTRY[nameOrFrom];
+        if (!entry)
+            throw new Error(`Unknown crew "${nameOrFrom}". Known: ${Object.keys(CREW_REGISTRY).join(', ')} — or pass --from <dir|zip|url>.`);
+        ref = ref || entry.defaultRef;
+        const kind = /^v?\d/.test(ref) ? 'tags' : 'heads';
+        url = `https://codeload.github.com/${entry.repo}/tar.gz/refs/${kind}/${ref}`;
+    }
+    else {
+        name = basename(new URL(url).pathname).replace(/\.(zip|tar\.gz|tgz)$/i, '') || nameOrFrom;
+        ref = ref || 'url';
+    }
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`Download failed: ${res.status} ${res.statusText} — ${url}`);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const files = stripCommonRoot(/\.zip($|\?)/i.test(url) ? readZip(buffer) : readTarGz(buffer));
+    const dir = join(crewCacheDir(), name, ref);
+    unpackTo(files, dir);
+    return loadPackFromDir(dir, url, ref);
+}
+// ── validation ──────────────────────────────────────────────────────────────
+export function validatePack(pack) {
+    const errors = [];
+    const { crew } = pack;
+    if (!crew.name || !/^[a-z0-9][a-z0-9-]*$/.test(crew.name))
+        errors.push('crew.json: name must be a kebab-case slug');
+    if (!crew.agents || !Object.keys(crew.agents).length)
+        errors.push('crew.json: no agents');
+    for (const [name, files] of pack.skills) {
+        const skill = files.get('SKILL.md');
+        if (!skill) {
+            errors.push(`skills/${name}: no SKILL.md`);
+            continue;
+        }
+        const { frontmatter } = parseFrontmatter(skill.toString('utf8'));
+        if (frontmatter.name !== name)
+            errors.push(`skills/${name}/SKILL.md: name "${frontmatter.name}" must equal the folder name`);
+        const desc = String(frontmatter.description || '');
+        if (!desc)
+            errors.push(`skills/${name}/SKILL.md: description is required`);
+        else if (desc.length > 1024)
+            errors.push(`skills/${name}/SKILL.md: description is ${desc.length} chars (max 1024)`);
+        // relative links must resolve inside the pack
+        const text = skill.toString('utf8');
+        for (const m of text.matchAll(/\]\(((?:\.\.\/|reference\/|scripts\/)[^)#]+)(?:#[^)]*)?\)/g)) {
+            const target = m[1];
+            const parts = target.split('/');
+            const resolved = parts[0] === '..' ? pack.skills.get(parts[1])?.has(parts.slice(2).join('/')) : files.has(target);
+            if (!resolved)
+                errors.push(`skills/${name}/SKILL.md: link ${target} does not resolve`);
+        }
+    }
+    for (const [slug, spec] of Object.entries(crew.agents || {})) {
+        const persona = pack.agents[slug];
+        if (!persona)
+            continue;
+        if (persona.frontmatter.name !== slug)
+            errors.push(`${spec.prompt}: frontmatter name "${persona.frontmatter.name}" must equal the slug ${slug}`);
+        if (!persona.frontmatter.description)
+            errors.push(`${spec.prompt}: description is required`);
+        const fmSkills = listOf(persona.frontmatter.skills).sort().join(',');
+        if (fmSkills !== [...spec.skills].sort().join(','))
+            errors.push(`${spec.prompt}: frontmatter skills [${fmSkills}] differ from crew.json [${spec.skills.join(',')}]`);
+        for (const s of spec.skills)
+            if (!pack.skills.has(s))
+                errors.push(`crew.json: agent ${slug} lists unknown skill ${s}`);
+        for (const d of spec.delegatesTo || [])
+            if (!crew.agents[d])
+                errors.push(`crew.json: agent ${slug} delegates to unknown ${d}`);
+        const tools = listOf(persona.frontmatter.tools);
+        if (!spec.capabilities.write && tools.some((t) => /^(Edit|Write|MultiEdit|NotebookEdit)$/.test(t)))
+            errors.push(`${spec.prompt}: read-only seat lists a write tool`);
+        if (spec.capabilities.spawn && !tools.includes('Agent'))
+            errors.push(`${spec.prompt}: a spawning seat needs the Agent tool`);
+    }
+    for (const [id, ch] of Object.entries(crew.channels || {}))
+        for (const m of ch.members)
+            if (!crew.agents[m])
+                errors.push(`crew.json: channel ${id} has unknown member ${m}`);
+    return errors;
+}
+const home = (o) => o.home || process.env.HOME || homedir();
+export function claudeRoot(o) {
+    return o.project ? join(resolve(o.project), '.claude') : join(home(o), '.claude');
+}
+export function agentsSkillsRoot(o) {
+    return o.project ? join(resolve(o.project), '.agents', 'skills') : join(home(o), '.agents', 'skills');
+}
+export function codexAgentsRoot(o) {
+    return o.project ? join(resolve(o.project), '.codex', 'agents') : join(home(o), '.codex', 'agents');
+}
+export function openclawRoot(pack, o) {
+    return o.project ? join(resolve(o.project), 'openclaw') : join(home(o), '.openclaw', 'workspaces', pack.crew.name);
+}
+function skillOps(pack, root, o, note) {
+    const ops = [];
+    for (const [name, files] of pack.skills) {
+        const path = join(root, name);
+        if (o.link)
+            ops.push({ kind: 'link', path, target: join(pack.root, pack.crew.skillsDir || 'skills', name), note: `${note} skill ${name} (symlink)` });
+        else
+            ops.push({ kind: 'dir', path, files, note: `${note} skill ${name} (${files.size} files)` });
+    }
+    return ops;
+}
+export function planClaude(pack, o) {
+    const root = claudeRoot(o);
+    const ops = skillOps(pack, join(root, 'skills'), o, 'claude');
+    for (const [slug, persona] of Object.entries(pack.agents)) {
+        const path = join(root, 'agents', `${slug}.md`);
+        if (o.link)
+            ops.push({ kind: 'link', path, target: join(pack.root, pack.crew.agents[slug].prompt), note: `claude agent ${slug} (symlink)` });
+        else
+            ops.push({ kind: 'file', path, content: persona.raw, note: `claude agent ${slug}` });
+    }
+    return ops;
+}
+/** Codex `.codex/agents/<slug>.toml` — the persona body becomes developer_instructions. */
+export function codexAgentToml(pack, slug, skillsBase) {
+    const spec = pack.crew.agents[slug];
+    const persona = pack.agents[slug];
+    const q = (s) => JSON.stringify(s);
+    const sandbox = spec.capabilities.write ? 'workspace-write' : 'read-only';
+    const extra = [
+        '',
+        `Skills for this seat live under ${skillsBase}/: ${spec.skills.join(', ')}.`,
+        spec.delegatesTo.length ? `Delegate with spawn_agent to: ${spec.delegatesTo.join(', ')}.` : 'You do not spawn other agents; report back to the seat that assigned you.',
+        spec.capabilities.spend ? 'You may run wji generation commands after the cost has been approved.' : 'You never run wji generation or spend credits.',
+    ].join('\n');
+    const body = `${persona.body.trimEnd()}\n${extra}\n`.replace(/"""/g, '\\"\\"\\"');
+    const lines = [
+        `# GENERATED by \`wji crew install\` from ${pack.crew.name}/agents/${slug}.md — edit the pack, not this file.`,
+        slug === 'wji-operator' || spec.capabilities.network
+            ? `# This seat needs network access: set [sandbox_workspace_write] network_access = true in ~/.codex/config.toml.`
+            : '',
+        `name = ${q(slug)}`,
+        `description = ${q(String(persona.frontmatter.description || spec.name))}`,
+    ];
+    if (spec.model)
+        lines.push(`model = ${q(spec.model)}`);
+    lines.push(`sandbox_mode = ${q(sandbox)}`, `developer_instructions = """`, body, `"""`, '');
+    for (const s of spec.skills)
+        lines.push('[[skills.config]]', `path = ${q(`${skillsBase}/${s}`)}`, 'enabled = true', '');
+    return lines.filter((l) => l !== undefined).join('\n');
+}
+export function planCodex(pack, o) {
+    const skillsRoot = agentsSkillsRoot(o);
+    const ops = skillOps(pack, skillsRoot, o, 'codex');
+    const base = o.project ? '.agents/skills' : skillsRoot;
+    for (const slug of Object.keys(pack.agents)) {
+        ops.push({ kind: 'file', path: join(codexAgentsRoot(o), `${slug}.toml`), content: codexAgentToml(pack, slug, base), note: `codex agent ${slug}` });
+    }
+    return ops;
+}
+/** OpenClaw tool ids per capability; one table so a rename is a one-line fix. */
+const OPENCLAW_TOOLS = {
+    read: ['read'],
+    write: ['write', 'edit'],
+    exec: ['exec'],
+    spawn: ['sessions_spawn', 'sessions_send', 'agents_list'],
+    network: ['web_fetch', 'browser'],
+};
+export function openclawSeatAgentsMd(pack, slug) {
+    const spec = pack.crew.agents[slug];
+    const caps = spec.capabilities;
+    const seat = [
+        `# Seat: ${slug} (${spec.name})`,
+        '',
+        `You are seat \`${slug}\` of the ${pack.crew.title || pack.crew.name} crew.`,
+        `- Skills allowed: ${spec.skills.join(', ')}`,
+        `- May spawn: ${spec.delegatesTo.length ? spec.delegatesTo.join(', ') : 'nobody — report back to the seat that assigned you'}`,
+        `- Spend credits / run generation: ${caps.spend ? 'yes, after the approved cost is relayed' : 'never'}`,
+        caps.exec === 'readonly' ? '- Shell use is read-only (validate / checkup / manifest / grep / diff); never edit files.' : caps.exec === 'engine' ? '- Shell use is the short-drama engine and read-only wji commands only.' : '',
+        !caps.write ? '- You do not write files.' : '',
+        '',
+    ]
+        .filter((l) => l !== '')
+        .join('\n');
+    return `${seat}\n${pack.agentsMd ? `\n---\n\n${pack.agentsMd.trimEnd()}\n` : ''}`;
+}
+export function openclawFragment(pack, workspacesRoot, repoPlaceholder = true) {
+    const ws = (slug) => (repoPlaceholder ? `\${WORKSPACES}/${slug}` : join(workspacesRoot, slug));
+    const entries = [];
+    for (const [slug, spec] of Object.entries(pack.crew.agents)) {
+        const c = spec.capabilities;
+        const allow = [...OPENCLAW_TOOLS.read, ...(c.write ? OPENCLAW_TOOLS.write : []), ...(c.exec ? OPENCLAW_TOOLS.exec : []), ...(c.spawn ? OPENCLAW_TOOLS.spawn : [])];
+        const deny = [...(c.write ? [] : OPENCLAW_TOOLS.write), ...(c.network ? [] : OPENCLAW_TOOLS.network), ...(c.spawn ? [] : ['sessions_spawn'])];
+        const peers = [...new Set([...spec.delegatesTo, ...Object.entries(pack.crew.agents).filter(([, s]) => s.delegatesTo.includes(slug)).map(([id]) => id)])];
+        entries.push(`    ${JSON.stringify(slug)}: {`, `      name: ${JSON.stringify(spec.name)},`, `      workspace: ${JSON.stringify(ws(slug))},`, spec.model ? `      model: ${JSON.stringify(spec.model)},` : '', `      skills: ${JSON.stringify(spec.skills)},`, `      tools: { allow: ${JSON.stringify(allow)}, deny: ${JSON.stringify(deny)} },`, `      subagents: { allowAgents: ${JSON.stringify(spec.delegatesTo)}${spec.delegatesTo.length ? ', delegationMode: "prefer"' : ''} },`, `      // agent-to-agent messaging peers: ${peers.join(', ') || 'none'}`, `    },`);
+    }
+    const bindings = [];
+    for (const [chId, ch] of Object.entries(pack.crew.channels || {})) {
+        bindings.push(`    // channel "${ch.name}" (${chId}): members ${ch.members.join(', ')} — fill in the real channel / group id`);
+        for (const m of ch.members)
+            bindings.push(`    { agentId: ${JSON.stringify(m)}, match: { channel: "TODO", peer: { kind: "group", id: "TODO:${chId}" } } },`);
+    }
+    return [
+        `// GENERATED by \`wji crew install\` from the ${pack.crew.name} pack. Merge into ~/.openclaw/openclaw.json`,
+        `// (agents.entries + bindings). ${repoPlaceholder ? '${WORKSPACES} = ' + workspacesRoot : ''}`,
+        '{',
+        '  agents: {',
+        `    defaults: { subagents: { allowAgents: ["*"], maxConcurrent: 4, maxSpawnDepth: 2 } },`,
+        '    entries: {',
+        ...entries.filter(Boolean),
+        '    },',
+        '  },',
+        `  tools: { agentToAgent: { enabled: true, allow: ${JSON.stringify(Object.keys(pack.crew.agents))} } },`,
+        '  bindings: [',
+        ...bindings,
+        '  ],',
+        '}',
+        '',
+    ].join('\n');
+}
+export function findOpenclaw() {
+    const candidates = [join(homedir(), '.openclaw', 'bin', 'openclaw')];
+    for (const c of candidates)
+        if (existsSync(c))
+            return c;
+    const which = spawnSync('which', ['openclaw'], { encoding: 'utf8' });
+    const path = which.status === 0 ? which.stdout.trim() : '';
+    return path || undefined;
+}
+export function planOpenclaw(pack, o, opts = {}) {
+    const skillsRoot = agentsSkillsRoot(o);
+    const ops = skillOps(pack, skillsRoot, o, 'openclaw');
+    const root = openclawRoot(pack, o);
+    for (const [slug, persona] of Object.entries(pack.agents)) {
+        const ws = join(root, slug);
+        ops.push({ kind: 'file', path: join(ws, 'SOUL.md'), content: `# ${pack.crew.agents[slug].name}\n\n${persona.body.trimEnd()}\n`, note: `openclaw ${slug}/SOUL.md` });
+        ops.push({ kind: 'file', path: join(ws, 'AGENTS.md'), content: openclawSeatAgentsMd(pack, slug), note: `openclaw ${slug}/AGENTS.md` });
+        ops.push({ kind: 'link', path: join(ws, 'skills'), target: skillsRoot, note: `openclaw ${slug}/skills → shared skills` });
+    }
+    ops.push({ kind: 'file', path: join(root, 'openclaw.agents.json5'), content: openclawFragment(pack, root, false), note: 'openclaw config fragment (merge by hand)' });
+    const bin = opts.register ? findOpenclaw() : undefined;
+    if (bin) {
+        const listed = spawnSync(bin, ['agents', 'list', '--json'], { encoding: 'utf8' });
+        const existing = new Set();
+        try {
+            const parsed = JSON.parse(listed.stdout || '[]');
+            for (const a of Array.isArray(parsed) ? parsed : parsed.agents || [])
+                existing.add(String(a.id || a.name));
+        }
+        catch {
+            /* unreadable list — register everything and let openclaw refuse duplicates */
+        }
+        for (const slug of Object.keys(pack.agents)) {
+            if (existing.has(slug))
+                continue;
+            ops.push({ kind: 'exec', argv: [bin, 'agents', 'add', slug, '--workspace', join(root, slug), '--non-interactive'], note: `openclaw agents add ${slug}` });
+        }
+    }
+    return ops;
+}
+/** The export layout the Grok bot platform imports: skills/ + bots/*.json + channels/*.json. */
+export function grokZip(pack) {
+    const entries = [];
+    const rootName = `${pack.crew.name}-export`;
+    const rewrite = (text) => text
+        // sibling-skill links become the platform's skill links
+        .replace(/\]\(\.\.\/([a-z0-9-]+)\/SKILL\.md\)/g, '](sand-workflow:$1)')
+        // sibling paths become the `{skill}/…` placeholder the platform's skills use
+        .replace(/\.\.\/([a-z0-9-]+)\//g, '{$1}/');
+    for (const [name, files] of pack.skills) {
+        for (const [path, content] of files) {
+            const text = /\.(md|mjs|js|json|txt|sh)$/i.test(path) ? rewrite(content.toString('utf8')) : content;
+            entries.push({ path: `${rootName}/skills/${name}/${path}`, content: text });
+        }
+    }
+    const bots = Object.entries(pack.crew.agents).map(([slug, spec]) => {
+        const persona = pack.agents[slug];
+        const description = `${String(persona.frontmatter.description || '')}\n\n${rewrite(persona.body).trim()}`;
+        return { slug, name: spec.name, title: spec.name, description };
+    });
+    for (const bot of bots)
+        entries.push({ path: `${rootName}/bots/${bot.slug}.json`, content: JSON.stringify(bot, null, 2) + '\n' });
+    const channels = Object.entries(pack.crew.channels || {}).map(([slug, ch]) => ({ slug, name: ch.name, memberSlugs: ch.members }));
+    for (const ch of channels)
+        entries.push({ path: `${rootName}/channels/${ch.slug}.json`, content: JSON.stringify(ch, null, 2) + '\n' });
+    const manifest = {
+        version: 2,
+        exportedAt: new Date().toISOString().slice(0, 10),
+        bots: bots.map((b) => ({ slug: b.slug, name: b.name, title: b.title, description: b.description })),
+        channels,
+        skills: [...pack.skills.keys()].sort(),
+        notes: `Portable ${pack.crew.title || pack.crew.name} pack built by \`wji crew install --for grok\`. Recreate bots from bots/*.json (name + description), channels from channels/*.json memberSlugs, copy every skills/<name> folder into the shared skills library. Account-local ids are never included.`,
+    };
+    entries.push({ path: `${rootName}/bots/crew-manifest.json`, content: JSON.stringify(manifest, null, 2) + '\n' });
+    const readme = [
+        `# ${pack.crew.title || pack.crew.name} export`,
+        '',
+        'Portable pack: skill folders + bot personas + channel recipes.',
+        '',
+        '1. **Skills** — copy each folder under `skills/` into the account\'s shared skills library.',
+        '2. **Bots** — create one agent per `bots/*.json` using the same `name` and `description`' + (pack.crew.entry ? ` (start with ${pack.crew.agents[pack.crew.entry]?.name || pack.crew.entry}).` : '.'),
+        '3. **Channels** — create groups from `channels/*.json` and add members by the listed slugs.',
+        '',
+        '| Bot | Owns |',
+        '| --- | --- |',
+        ...bots.map((b) => `| ${b.name} | ${String(pack.agents[b.slug].frontmatter.description || '').split(/[.。]/)[0]} |`),
+        '',
+    ].join('\n');
+    entries.push({ path: `${rootName}/README.md`, content: readme });
+    return { zip: createZip(entries), entries: entries.length };
+}
+export function installedPath() {
+    return join(crewCacheDir(), 'installed.json');
+}
+export function readInstalled() {
+    const p = installedPath();
+    if (!existsSync(p))
+        return {};
+    try {
+        return JSON.parse(readFileSync(p, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeInstalled(data) {
+    mkdirSync(dirname(installedPath()), { recursive: true });
+    writeFileSync(installedPath(), JSON.stringify(data, null, 2) + '\n');
+}
+function removePath(path) {
+    if (!existsSync(path) && !isSymlink(path))
+        return;
+    if (isSymlink(path) || !lstatSync(path).isDirectory())
+        rmSync(path, { force: true });
+    else
+        rmSync(path, { recursive: true, force: true });
+}
+const isSymlink = (p) => {
+    try {
+        return lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+};
+/** Run the ops; returns every path written plus the notes of executed commands. */
+export function applyOps(ops, log) {
+    const paths = [];
+    const notes = [];
+    for (const op of ops) {
+        if (op.kind === 'exec') {
+            const res = spawnSync(op.argv[0], op.argv.slice(1), { encoding: 'utf8' });
+            const tail = (res.stdout || res.stderr || '').trim().split('\n').slice(-1)[0] || '';
+            notes.push(`${op.note}: ${res.status === 0 ? 'ok' : `exit ${res.status}`}${tail ? ` — ${tail}` : ''}`);
+            log(`  ${res.status === 0 ? '✓' : '✗'} ${op.note}${tail ? ` — ${tail}` : ''}`);
+            continue;
+        }
+        mkdirSync(dirname(op.path), { recursive: true });
+        if (op.kind === 'link') {
+            removePath(op.path);
+            symlinkSync(op.target, op.path);
+        }
+        else if (op.kind === 'file') {
+            writeFileSync(op.path, op.content);
+        }
+        else {
+            removePath(op.path);
+            for (const [rel, content] of op.files) {
+                const full = join(op.path, rel);
+                mkdirSync(dirname(full), { recursive: true });
+                writeFileSync(full, content);
+            }
+        }
+        paths.push(op.path);
+        log(`  ✓ ${op.note} → ${op.path}`);
+    }
+    return { paths, notes };
+}
+export function describeOp(op) {
+    if (op.kind === 'exec')
+        return `run   ${op.argv.join(' ')}`;
+    if (op.kind === 'link')
+        return `link  ${op.path} → ${op.target}`;
+    if (op.kind === 'file')
+        return `write ${op.path}`;
+    return `copy  ${op.path} (${op.files.size} files)`;
+}
+export function pathState(path) {
+    if (isSymlink(path))
+        return existsSync(path) ? 'link' : 'missing';
+    return existsSync(path) ? 'ok' : 'missing';
+}
+export function uninstallPaths(paths) {
+    for (const p of paths)
+        removePath(p);
+}
+export function relOrAbs(path) {
+    const rel = relative(process.cwd(), path);
+    return rel && !rel.startsWith('..') && !isAbsolute(rel) ? rel : path;
+}
+export function linkTarget(path) {
+    return isSymlink(path) ? readlinkSync(path) : undefined;
+}

package/dist/index.js

@@ -16,6 +16,7 @@ import { profileCommand } from './commands/profile.js';
 import { presetCommand } from './commands/preset.js';
 import { skillCommand } from './commands/skill.js';
 import { canvasCommand } from './commands/canvas.js';
+import { crewCommand } from './commands/crew.js';
 // 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;
@@ -67,6 +68,7 @@ program.addCommand(profileCommand(globals));
 program.addCommand(presetCommand(globals));
 program.addCommand(skillCommand(globals));
 program.addCommand(canvasCommand(globals));
+program.addCommand(crewCommand(globals));
 program.addHelpText('after', `
 Examples:
   wji auth login --email you@example.com

package/package.json

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

package/skill/wji/SKILL.md

@@ -302,6 +302,15 @@ System keys currently include `image`, `document`, `workspace-dataset`,
 When authoring, edit a pulled folder and `skill push` it again, or
 `skill update <id> --dir ./my-skill` to replace its files.
 
+**Crews** are skill packs with agent seats (a `crew.json` + `agents/<seat>.md`
+next to `skills/`). `wji crew install <name> --for claude|codex|openclaw|grok|all`
+installs one into the host (Claude Code: `~/.claude/skills` + `~/.claude/agents`;
+Codex: `~/.agents/skills` + `~/.codex/agents/*.toml`; OpenClaw: workspaces under
+`~/.openclaw/workspaces/<crew>/` plus a JSON5 fragment to merge by hand; Grok bot:
+an import zip). `--dry-run` shows the plan, `--from <dir|zip|url>` bypasses the
+registry, `wji crew status` / `uninstall` track what was written, and
+`wji crew check <dir>` validates a pack. The `short-drama` crew is the known one.
+
 Bundle limits: at most 200 markdown files, 2MB per file, 20MB in total and a
 5MB zip; 50 user skills per account. `skill update --dir` sends files in the
 request body, where each file is capped far lower, at **200,000 characters** —
@@ -332,12 +341,17 @@ open). Every `wji canvas` command then targets that canvas; pass
 ```bash
 wji canvas status                     # linked canvas + selected nodes (ids, asset URLs, settings)
 wji canvas nodes                      # every node; * marks generate nodes
+wji canvas nodes --tag C01            # nodes with the color tag labelled C01 (or --tag red, --untagged)
+wji canvas nodes -n '^C0[1-3] '       # nodes whose name matches a regex (case-insensitive); combines with --tag/-k
+wji canvas tags                       # color tags on the canvas: color, label, node count
 wji canvas get <nodeId>               # full detail incl. references
 wji asset download <assetId…> -o <dir>   # then look at the images yourself
 
 wji canvas create E01 -w <workspaceId>  # new empty canvas; then --canvas <id>
 wji canvas add video --from <imgNode> <imgNode> -m <model> -r 16:9 -d 8 -p "@image1 … @image2 …"
 wji canvas add text -t "shot list…" --at 0,600
+wji canvas add text --text-file prompt.txt --plain --size 600,900   # plain text keeps its line breaks; node 600×900
+wji canvas set <nodeId> --text-file notes.md --size 520,700           # replace the text, resize
 wji canvas add image --asset <assetId> -n "Ada sheet"     # display node for an existing asset
 wji canvas add dataset --dataset <fsnodeId>                # card bound to a workspace dataset
 wji canvas set <nodeId> -p "new prompt"        # merges: other settings stay
@@ -387,6 +401,10 @@ wji canvas rm <nodeId…>                        # destructive — see Rules
 - Take new ids from the command's own output (`wji --json canvas add … | jq
   -r .id`), not by searching names — names repeat on a canvas. In zsh a
   variable holding several ids is not word-split; pass the ids literally.
+- Text, title and comment nodes are **Markdown** on the web: a single line break
+  joins the lines into one paragraph (the CLI warns). For prompts and other plain
+  text pass `--plain` (line breaks become Markdown hard breaks); `--size w,h`
+  sets the node's box so a long prompt is readable without scrolling.
 - Changes show up live in the user's open canvas; there's no need to ask them
   to reload.
 - `canvas gen` sends exactly what the canvas's own Generate button sends

package/skill/wji/reference/commands.md

@@ -162,11 +162,12 @@ updates live.
 | `canvas unlink` | `DELETE /canvas-link`; the tab turns its button off at its next heartbeat (≤ 60s) |
 | `canvas list [-w]` | canvases under each InfiniteCanvas app: `GET /workspace/list/:id/fs/:appId` → `workspace-v2/canvases` children |
 | `canvas create <name> [-w] [--app]` | `POST /fsnode/create` a `workspace-v2/canvas` folder under that `canvases` folder with the web's initial content (`{data:{viewport, backgroundMode:'dots'}, metadata:{}}`) |
-| `canvas nodes [-c] [-k kind]` | `GET /fsnode/list/:canvasId/children?limit=-1` + `POST /assets/check-status` |
+| `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 edges [-c] [--node]` | the `canvas/edge` children |
-| `canvas add <kind> [-c] [-n] [-t\|--text-file] [--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` |
-| `canvas set <nodeId> [-c] [-n] [-t] [--move x,y] [-p] [-m] [-r] [--resolution] [-d] [--set]` | read → merge → `PATCH /fsnode/list/:id` |
+| `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` |
 | `canvas connect <from> <to> [-c]` | `POST /fsnode/create` (`canvas/edge`); a first/last-frame video model gets `videoFrameSlot` start, then end |
 | `canvas disconnect <from> <to> [-c]` | `DELETE /fsnode/list/:edgeId` |
 | `canvas rm <nodeIds...> [-c] [-y]` | deletes the nodes' edges, then the nodes; refuses nodes still generating |
@@ -179,6 +180,12 @@ Storage format (what the web canvas writes):
   `generate` with `content.generate {prompt, model, ratio, resolution,
   duration, values, improvePromptEnabled, historyId?, pendingAssetId?}`. Width
   and height are not stored.
+- Color tag: the node stores only `content.colorTag {colorId}`, one of
+  `rose` (red), `orange`, `amber` (yellow), `lime` (green), `teal`, `sky`
+  (blue), `violet` (purple), `fuchsia` (pink). The label is per color per
+  canvas, on the canvas folder: `content.colorTagNames {rose: "C01", …}`, so
+  every red node on a canvas shares one label. A `name` left on an old node's
+  `colorTag` is ignored, as on the web.
 - Edge: `mimetype canvas/edge`, name `连线`, `content {fromNodeId, toNodeId,
   sourceHandle, targetHandle, videoFrameSlot?}`. References are incoming edges
   sorted by `sort` then id, numbered per source kind.
@@ -339,6 +346,28 @@ Only `.md` files persist (the importer drops everything else); scripts belong to
 | `skill update <id> [-n] [-d] [--visibility] [--dir] [-y]` | `PUT /ai/skill/:id` — metadata, or replace **all** files from `--dir` (confirms first) |
 | `skill rm <id> [-y]` | `DELETE /ai/skill/:id` |
 
+## crew
+
+Crew packs are local or remote folders (`crew.json`, `agents/<seat>.md`, `skills/<name>/SKILL.md`, `AGENTS.md`) — no WJI API involved.
+
+| Command | Behaviour |
+| --- | --- |
+| `crew install [name] --for <claude,codex,openclaw,grok\|all> [--from dir\|zip\|tar.gz\|url] [--ref] [--project dir] [--link] [--out zip] [--no-register] [--dry-run] [-y]` | fetches the pack (registry → GitHub tarball, cached under `~/.wji/crews/`), validates it, prints the plan, then per host: **claude** copies `skills/*` → `~/.claude/skills/` and `agents/*.md` → `~/.claude/agents/`; **codex** copies skills → `~/.agents/skills/` and writes `~/.codex/agents/<seat>.toml` (`developer_instructions` = persona body, `sandbox_mode` from capabilities, `[[skills.config]]` per skill); **openclaw** shares `~/.agents/skills/`, writes `~/.openclaw/workspaces/<crew>/<seat>/{AGENTS.md,SOUL.md,skills→}` + `openclaw.agents.json5` and runs `openclaw agents add` when the binary exists; **grok** writes `<crew>-export.zip` (`skills/`, `bots/*.json`, `bots/crew-manifest.json`, `channels/*.json`, sibling links rewritten to `sand-workflow:`). `--project` targets `<dir>/.claude`, `.agents`, `.codex`, `openclaw` instead of `$HOME` |
+| `crew status [name]` | reads `~/.wji/crews/installed.json`; per path ✓ / ↗ symlink / ✗ missing |
+| `crew uninstall <name> [--for targets] [-y]` | removes exactly the recorded paths; reminds you to clean `openclaw.json` by hand |
+| `crew check <dir>` | validates `crew.json` ↔ `agents/*.md` (names, skills, tools vs capabilities), every `SKILL.md` (name == folder, description ≤ 1024) and that relative links resolve |
+
+## crew
+
+Crew packs are local/remote folders (`crew.json`, `agents/<seat>.md`, `skills/<name>/SKILL.md`, `AGENTS.md`) — no WJI API involved.
+
+| Command | Behaviour |
+| --- | --- |
+| `crew install [name] --for <claude,codex,openclaw,grok\|all> [--from dir\|zip\|tar.gz\|url] [--ref] [--project dir] [--link] [--out zip] [--no-register] [--dry-run] [-y]` | fetches the pack (registry → GitHub tarball, cached under `~/.wji/crews/`), validates it, prints the plan, then per host: **claude** copies `skills/*` → `~/.claude/skills/` and `agents/*.md` → `~/.claude/agents/`; **codex** copies skills → `~/.agents/skills/` and writes `~/.codex/agents/<seat>.toml` (`developer_instructions` = persona body, `sandbox_mode` from capabilities, `[[skills.config]]` per skill); **openclaw** shares `~/.agents/skills/`, writes `~/.openclaw/workspaces/<crew>/<seat>/{AGENTS.md,SOUL.md,skills→}` + `openclaw.agents.json5` and runs `openclaw agents add` when the binary exists; **grok** writes `<crew>-export.zip` (`skills/`, `bots/*.json`, `bots/crew-manifest.json`, `channels/*.json`, sibling links rewritten to `sand-workflow:`). `--project` targets `<dir>/.claude`, `.agents`, `.codex`, `openclaw` instead of `$HOME` |
+| `crew status [name]` | reads `~/.wji/crews/installed.json`; per path ✓ / ↗ symlink / ✗ missing |
+| `crew uninstall <name> [--for targets] [-y]` | removes exactly the recorded paths; reminds you to clean `openclaw.json` by hand |
+| `crew check <dir>` | validates `crew.json` ↔ `agents/*.md` (names, skills, tools vs capabilities), every `SKILL.md` (name == folder, description ≤ 1024) and that relative links resolve |
+
 Import rules: the zip must contain `SKILL.md` at its root (or one folder deep — a
 single common root folder is stripped). `SKILL.md` frontmatter `name:` is
 required; `description:` is read too. Visibility is `private` (default) or