@bpmnkit/cli 0.0.36 → 0.1.0

package/README.md

@@ -9,7 +9,7 @@
   [![ai-assisted](https://img.shields.io/badge/AI--assisted-claude-8b5cf6?style=flat-square)](https://github.com/bpmnkit/monorepo)
   [![experimental](https://img.shields.io/badge/status-experimental-f59e0b?style=flat-square)](https://github.com/bpmnkit/monorepo)
 
-  [Website](https://bpmnkit.com) · [Documentation](https://docs.bpmnkit.com) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/apps/cli/CHANGELOG.md)
+  [Website](https://bpmnkit.com) · [Documentation](https://bpmnkit.com/docs) · [GitHub](https://github.com/bpmnkit/monorepo) · [Changelog](https://github.com/bpmnkit/monorepo/blob/main/apps/cli/CHANGELOG.md)
 </div>
 
 ---
@@ -103,10 +103,12 @@ casen instances list --state active
 | [`@bpmnkit/plugins`](https://www.npmjs.com/package/@bpmnkit/plugins) | 22 composable canvas plugins |
 | [`@bpmnkit/api`](https://www.npmjs.com/package/@bpmnkit/api) | Camunda 8 REST API TypeScript client |
 | [`@bpmnkit/ascii`](https://www.npmjs.com/package/@bpmnkit/ascii) | Render BPMN diagrams as Unicode ASCII art |
+| [`@bpmnkit/docspack`](https://www.npmjs.com/package/@bpmnkit/docspack) | BPMN Kit docs as an offline docspack package for AI agents |
 | [`@bpmnkit/ui`](https://www.npmjs.com/package/@bpmnkit/ui) | Shared design tokens and UI components |
 | [`@bpmnkit/profiles`](https://www.npmjs.com/package/@bpmnkit/profiles) | Shared auth, profile storage, and client factories for CLI & proxy |
 | [`@bpmnkit/operate`](https://www.npmjs.com/package/@bpmnkit/operate) | Monitoring & operations frontend for Camunda clusters |
 | [`@bpmnkit/connector-gen`](https://www.npmjs.com/package/@bpmnkit/connector-gen) | Generate connector templates from OpenAPI specs |
+| [`@bpmnkit/connectors`](https://www.npmjs.com/package/@bpmnkit/connectors) | Camunda 8 OOTB connector catalog and deterministic template application |
 | [`@bpmnkit/proxy`](https://www.npmjs.com/package/@bpmnkit/proxy) | Local AI bridge and Camunda API proxy server |
 | [`@bpmnkit/patterns`](https://www.npmjs.com/package/@bpmnkit/patterns) | Domain process patterns for BPMNKit AIKit |
 | [`@bpmnkit/reebe-wasm`](https://www.npmjs.com/package/@bpmnkit/reebe-wasm) | WebAssembly BPMN engine for browser simulation |

package/dist/commands/connector.js

@@ -1,5 +1,84 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
+import { getTemplate, listConnectors, searchConnectors } from "@bpmnkit/connectors";
+const searchCmd = {
+    name: "search",
+    description: "Search the bundled Camunda 8 out-of-the-box connector catalog (Slack, HTTP, AWS, AI Agent, …)",
+    args: [
+        { name: "query", description: 'Search terms, e.g. "slack" or "send email"', required: true },
+    ],
+    examples: [{ description: "Find the Slack connector", command: "casen connector search slack" }],
+    async run(ctx) {
+        const query = ctx.positional.join(" ");
+        const results = searchConnectors(query);
+        if (results.length === 0) {
+            ctx.output.info(`No connectors matched "${query}". Try 'casen connector list' to browse all.`);
+            return;
+        }
+        ctx.output.printList({ items: results }, [
+            { key: "id", header: "TEMPLATE ID", maxWidth: 48 },
+            { key: "direction", header: "DIRECTION", maxWidth: 18 },
+            { key: "taskType", header: "TASK TYPE", maxWidth: 32 },
+            { key: "description", header: "DESCRIPTION", maxWidth: 50 },
+        ]);
+    },
+};
+const listCatalogCmd = {
+    name: "list",
+    description: "List all bundled Camunda 8 out-of-the-box connector templates",
+    async run(ctx) {
+        ctx.output.printList({ items: listConnectors() }, [
+            { key: "id", header: "TEMPLATE ID", maxWidth: 48 },
+            { key: "direction", header: "DIRECTION", maxWidth: 18 },
+            { key: "taskType", header: "TASK TYPE", maxWidth: 32 },
+        ]);
+    },
+};
+const showCmd = {
+    name: "show",
+    description: "Show a connector template's required/optional input keys",
+    args: [
+        {
+            name: "templateId",
+            description: "Template id, e.g. io.camunda.connectors.Slack.v1",
+            required: true,
+        },
+    ],
+    examples: [
+        {
+            description: "Show the Slack connector's inputs",
+            command: "casen connector show io.camunda.connectors.Slack.v1",
+        },
+    ],
+    async run(ctx) {
+        const templateId = ctx.positional[0];
+        if (!templateId)
+            throw new Error("Missing required argument: <templateId>");
+        const summary = searchConnectors(templateId).find((s) => s.id === templateId) ??
+            listConnectors().find((s) => s.id === templateId);
+        if (!summary || !getTemplate(templateId)) {
+            throw new Error(`Unknown connector template "${templateId}". Use 'casen connector search <query>' to find one.`);
+        }
+        ctx.output.info(`${summary.name}  (${summary.id})`);
+        if (summary.taskType)
+            ctx.output.info(`Task type: ${summary.taskType}`);
+        ctx.output.info(`Direction: ${summary.direction}`);
+        if (summary.description)
+            ctx.output.info(summary.description);
+        if (summary.requiredInputs.length > 0) {
+            ctx.output.info("\nRequired inputs:");
+            for (const i of summary.requiredInputs) {
+                ctx.output.info(`  ${i.key}${i.isSecret ? " (secret)" : ""} — ${i.label}`);
+            }
+        }
+        if (summary.optionalInputs.length > 0) {
+            ctx.output.info("\nOptional inputs:");
+            for (const i of summary.optionalInputs) {
+                ctx.output.info(`  ${i.key}${i.isSecret ? " (secret)" : ""} — ${i.label}`);
+            }
+        }
+    },
+};
 export const connectorGroup = {
     name: "connector",
     description: "Generate Camunda REST connector element templates from OpenAPI specs",
@@ -167,6 +246,9 @@ export const connectorGroup = {
                 ]);
             },
         },
+        searchCmd,
+        listCatalogCmd,
+        showCmd,
     ],
 };
 //# sourceMappingURL=connector.js.map

package/dist/commands/deploy.js

@@ -0,0 +1,70 @@
+import { readFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { getActiveProfile, getAuthHeader } from "@bpmnkit/profiles";
+const ZEEBE_ADDRESS = (process.env.ZEEBE_ADDRESS ?? "http://localhost:26500").replace(/\/$/, "");
+const deployCmd = {
+    name: "deploy",
+    description: "Deploy a BPMN (or DMN/form) file to local Reebe or the active Camunda 8 profile",
+    args: [{ name: "file", description: "Path to the resource file", required: true }],
+    flags: [
+        {
+            name: "target",
+            description: 'Deployment target: "local" (Reebe, via ZEEBE_ADDRESS) or "camunda8" (active profile)',
+            type: "string",
+            default: "local",
+            enum: ["local", "camunda8"],
+        },
+    ],
+    examples: [
+        { description: "Deploy to local Reebe", command: "casen deploy deploy order-process.bpmn" },
+        {
+            description: "Deploy to Camunda 8",
+            command: "casen deploy deploy order-process.bpmn --target camunda8",
+        },
+    ],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const absPath = resolve(filePath);
+        const content = await readFile(absPath, "utf-8").catch(() => {
+            throw new Error(`Cannot read file: ${absPath}`);
+        });
+        const formData = new FormData();
+        formData.append("resources[]", new Blob([content], { type: "application/octet-stream" }), basename(absPath));
+        const target = typeof ctx.flags.target === "string" ? ctx.flags.target : "local";
+        if (target === "camunda8") {
+            const profile = getActiveProfile();
+            if (!profile?.config.baseUrl) {
+                throw new Error("No active Camunda 8 profile. Run: casen profile create");
+            }
+            const authHeader = await getAuthHeader(profile.config);
+            const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+            const res = await fetch(`${baseUrl}/v2/deployments`, {
+                method: "POST",
+                headers: { authorization: authHeader },
+                body: formData,
+            });
+            if (!res.ok)
+                throw new Error(`Camunda 8 deploy failed: ${res.status} ${await res.text()}`);
+            ctx.output.print({ success: true, target: "camunda8", result: await res.json() });
+            return;
+        }
+        let res;
+        try {
+            res = await fetch(`${ZEEBE_ADDRESS}/v2/deployments`, { method: "POST", body: formData });
+        }
+        catch (err) {
+            throw new Error(`Cannot reach Reebe at ${ZEEBE_ADDRESS}. Start it with: casen reebe start\n${String(err)}`);
+        }
+        if (!res.ok)
+            throw new Error(`Local deploy failed: ${res.status} ${await res.text()}`);
+        ctx.output.print({ success: true, target: "local", result: await res.json() });
+    },
+};
+export const deployGroup = {
+    name: "deploy",
+    description: "Deploy BPMN/DMN/form resources to local Reebe or Camunda 8",
+    commands: [deployCmd],
+};
+//# sourceMappingURL=deploy.js.map

package/dist/commands/generate.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { Bpmn, compactify, expand } from "@bpmnkit/core";
+import { resolve } from "node:path";
+import { Bpmn, applyAutoLayout, applyBpmnOperations, compactify, expand } from "@bpmnkit/core";
 // ── JSON schema reference ─────────────────────────────────────────────────────
 const SCHEMA_HELP = `CompactDiagram JSON schema — for --definition and stdin input
 ==============================================================
@@ -455,6 +456,35 @@ async function readStdin() {
     }
     return Buffer.concat(chunks).toString("utf-8").trim();
 }
+// ── Output path guard ─────────────────────────────────────────────────────────
+/**
+ * Decide where `--input` mode writes, refusing to replace the input file unless
+ * the caller asked for it explicitly.
+ *
+ * The patch itself is applied to the full model, so nothing outside it is lost.
+ * Replacing the source is still destructive — the diagram is re-laid out, and a
+ * mistaken patch has nowhere to be compared against — so in-place replacement
+ * has to be asked for by name.
+ *
+ * @param inputFile - The `--input` path.
+ * @param outputFlag - The `--output` path, if any. `-` (stdout) is handled by the caller.
+ * @param force - Whether `--force` was passed.
+ * @returns The path to write to.
+ * @throws If the write would replace `inputFile` and `force` is false.
+ */
+export function resolveModifyOutputPath({ inputFile, outputFlag, force, }) {
+    const output = typeof outputFlag === "string" && outputFlag.length > 0 ? outputFlag : undefined;
+    const inPlace = output === undefined || resolve(output) === resolve(inputFile);
+    if (inPlace && !force) {
+        throw new Error([
+            `Refusing to overwrite ${inputFile}.`,
+            "The patch applies to the full model, so nothing is dropped, but the diagram is " +
+                "re-laid out and the original is gone once it is replaced.",
+            `Write elsewhere with --output <file>, or pass --force to replace ${inputFile} anyway.`,
+        ].join("\n"));
+    }
+    return output ?? inputFile;
+}
 // ── Command ───────────────────────────────────────────────────────────────────
 const generateBpmnCmd = {
     name: "bpmn",
@@ -500,7 +530,9 @@ const generateBpmnCmd = {
         {
             name: "input",
             short: "f",
-            description: "Existing .bpmn file to load and modify",
+            description: "Existing .bpmn file to load and modify. The patch is applied to the full model, so " +
+                "pools, lanes, data wiring and Zeebe detail are preserved; the diagram is re-laid " +
+                "out. Requires --output, or --force to replace it in place.",
             type: "string",
         },
         {
@@ -513,6 +545,11 @@ const generateBpmnCmd = {
             description: "Print the CompactDiagram JSON of --input and exit (for AI inspection of existing files)",
             type: "boolean",
         },
+        {
+            name: "force",
+            description: "Allow --input to be replaced in place. Prefer --output <file>.",
+            type: "boolean",
+        },
     ],
     examples: [
         {
@@ -553,11 +590,11 @@ const generateBpmnCmd = {
         },
         {
             description: "Add a new gateway path to an existing file",
-            command: 'casen generate bpmn --input order.bpmn --patch \'{"elements":[{"id":"notify","type":"serviceTask","name":"Notify","jobType":"notify-worker"},{"id":"end2","type":"endEvent","name":"Notified"}],"flows":[{"id":"fn1","from":"gw","to":"notify","condition":"= urgent"},{"id":"fn2","from":"notify","to":"end2"}]}\'',
+            command: 'casen generate bpmn --input order.bpmn --output order.patched.bpmn --patch \'{"elements":[{"id":"notify","type":"serviceTask","name":"Notify","jobType":"notify-worker"},{"id":"end2","type":"endEvent","name":"Notified"}],"flows":[{"id":"fn1","from":"gw","to":"notify","condition":"= urgent"},{"id":"fn2","from":"notify","to":"end2"}]}\'',
         },
         {
             description: "Pipe a patch from AI output",
-            command: 'echo \'{"elements":[...],"flows":[...]}\' | casen generate bpmn --input order.bpmn',
+            command: 'echo \'{"elements":[...],"flows":[...]}\' | casen generate bpmn --input order.bpmn --output order.patched.bpmn',
         },
         {
             description: "Re-apply auto-layout to an existing file",
@@ -580,12 +617,20 @@ const generateBpmnCmd = {
         if (inputFile) {
             const xml = await readFile(inputFile, "utf-8");
             const defs = Bpmn.parse(xml);
-            const compact = compactify(defs);
             // --dump-compact: print JSON for AI inspection and exit
             if (ctx.flags["dump-compact"]) {
-                process.stdout.write(`${JSON.stringify(compact, null, 2)}\n`);
+                process.stdout.write(`${JSON.stringify(compactify(defs), null, 2)}\n`);
                 return;
             }
+            // Settle the destination before reading stdin or building the patch, so an
+            // unwritable target fails immediately instead of after the work is done.
+            const outputPath = outputFlag === "-"
+                ? null
+                : resolveModifyOutputPath({
+                    inputFile,
+                    outputFlag,
+                    force: ctx.flags.force === true,
+                });
             // Resolve patch from --patch flag or stdin
             let patch = null;
             if (patchFlag) {
@@ -607,22 +652,40 @@ const generateBpmnCmd = {
                     }
                 }
             }
-            // Apply patch to first process (covers all single-process cases)
+            // Apply the patch to the full model, not to the compact view of it: an
+            // element added this way leaves the document's pools, lanes, data
+            // wiring and Zeebe detail exactly where they were.
+            let edited = defs;
             if (patch) {
-                const proc = compact.processes[0];
-                if (!proc)
+                const process = defs.processes[0];
+                if (!process)
                     throw new Error("Input BPMN has no processes");
-                if (patch.elements?.length)
-                    proc.elements.push(...patch.elements);
-                if (patch.flows?.length)
-                    proc.flows.push(...patch.flows);
+                const operations = [
+                    ...(patch.elements ?? []).map((element) => ({ op: "insert", element, parent: process.id })),
+                    ...(patch.flows ?? []).map((flow) => ({
+                        op: "add_flow",
+                        id: flow.id,
+                        parent: process.id,
+                        from: flow.from,
+                        to: flow.to,
+                        name: flow.name,
+                        condition: flow.condition,
+                    })),
+                ];
+                try {
+                    edited = applyBpmnOperations(defs, operations).definitions;
+                }
+                catch (error) {
+                    // Unresolved ids used to be skipped in silence, so a patch naming a
+                    // misspelled element reported success and changed nothing.
+                    throw new Error(`Patch could not be applied: ${error instanceof Error ? error.message : String(error)}`);
+                }
             }
-            const patched = Bpmn.export(expand(compact));
-            if (outputFlag === "-") {
+            const patched = Bpmn.export(applyAutoLayout(edited));
+            if (outputPath === null) {
                 process.stdout.write(patched);
                 return;
             }
-            const outputPath = typeof outputFlag === "string" && outputFlag.length > 0 ? outputFlag : inputFile;
             await writeFile(outputPath, patched, "utf-8");
             ctx.output.ok(patch ? `Patched and written to ${outputPath}` : `Re-laid-out and written to ${outputPath}`);
             return;

package/dist/commands/index.js

@@ -4,8 +4,11 @@ import { askGroup } from "./ask.js";
 import { getDmnReqsXmlCmd, getDmnXmlCmd, getStartFormCmd, getUserTaskFormCmd, getXmlCmd, renderBpmnCmd, } from "./bpmn.js";
 import { completionGroup } from "./completion.js";
 import { connectorGroup } from "./connector.js";
+import { deployGroup } from "./deploy.js";
 import { generateGroup } from "./generate.js";
 import { lintGroup } from "./lint.js";
+import { patternGroup } from "./pattern.js";
+import { planGroup } from "./plan.js";
 import { pluginGroup } from "./plugin.js";
 import { profileGroup } from "./profile.js";
 import { proxyGroup } from "./proxy.js";
@@ -14,6 +17,7 @@ import { computeRelations } from "./relations.js";
 import { settingsGroup } from "./settings.js";
 import { skillsGroup } from "./skills.js";
 import { storyGroup } from "./story.js";
+import { synthGroup } from "./synth.js";
 import { testGroup } from "./test.js";
 import { viewGroup } from "./view.js";
 import { workerStartCmd } from "./worker-start.js";
@@ -57,13 +61,17 @@ const workerGroup = {
 /** Pinned groups shown above the separator in the main TUI menu. */
 export const pinnedGroups = [
     askGroup,
+    deployGroup,
     generateGroup,
     lintGroup,
+    patternGroup,
+    planGroup,
     proxyGroup,
     reebeGroup,
     skillsGroup,
     storyGroup,
     settingsGroup,
+    synthGroup,
     testGroup,
     viewGroup,
     workerGroup,

package/dist/commands/lint.js

@@ -1,5 +1,17 @@
 import { readFile, writeFile } from "node:fs/promises";
+import { applyConnectorTemplate } from "@bpmnkit/connectors";
 import { Bpmn, compactify, optimize } from "@bpmnkit/core";
+/** Resolves a connector template's missing required keys via @bpmnkit/connectors, for the `connector/*` lint rule. */
+export function resolveConnectorRequirements(templateId, boundKeys) {
+    const values = Object.fromEntries(boundKeys.map((k) => [k, "x"]));
+    const result = applyConnectorTemplate(templateId, values);
+    // Only "missing-required" problems mean something is actually unset — an "unknown-key"
+    // problem here just means a bound key doesn't match propertyKey()'s lookup key (e.g. a
+    // property whose `id` differs from its zeebe:input binding name), not a missing value.
+    return result.problems
+        .filter((p) => p.kind === "missing-required" && p.key !== undefined)
+        .map((p) => p.key);
+}
 const SEVERITY_SYMBOL = {
     error: "✖",
     warning: "⚠",
@@ -16,6 +28,11 @@ const lintCmd = {
             description: "Comma-separated categories to run (default: all)",
             type: "string",
         },
+        {
+            name: "profile",
+            description: 'Lint profile. "deploy" runs every category and shows only error-severity findings — the deploy-readiness gate.',
+            type: "string",
+        },
         {
             name: "format",
             description: "Output format: text (default) or json",
@@ -27,6 +44,13 @@ const lintCmd = {
             type: "boolean",
         },
     ],
+    examples: [
+        { description: "Lint a file", command: "casen lint lint order-process.bpmn" },
+        {
+            description: "Deploy-readiness gate (errors only)",
+            command: "casen lint lint order-process.bpmn --profile deploy",
+        },
+    ],
     async run(ctx) {
         const filePath = ctx.positional[0];
         if (!filePath)
@@ -37,8 +61,14 @@ const lintCmd = {
         const categories = typeof categoriesFlag === "string" && categoriesFlag.length > 0
             ? categoriesFlag.split(",").map((s) => s.trim())
             : undefined;
-        const report = optimize(defs, categories !== undefined ? { categories } : undefined);
-        const { findings } = report;
+        const deployProfile = ctx.flags.profile === "deploy";
+        const report = optimize(defs, {
+            ...(categories !== undefined ? { categories } : {}),
+            resolveConnectorRequirements,
+        });
+        const findings = deployProfile
+            ? report.findings.filter((f) => f.severity === "error")
+            : report.findings;
         // --fix: apply all auto-fixable findings and write back
         if (ctx.flags.fix) {
             const fixable = findings.filter((f) => f.applyFix);
@@ -67,10 +97,10 @@ const lintCmd = {
             const elIds = f.elementIds.length > 0 ? ` [${f.elementIds.join(", ")}]` : "";
             ctx.output.info(`${symbol} [${f.category}]${elIds} ${f.message}`);
         }
-        const { total, bySeverity } = report.summary;
-        const errorCount = bySeverity.error ?? 0;
-        const warnCount = bySeverity.warning ?? 0;
-        const infoCount = bySeverity.info ?? 0;
+        const total = findings.length;
+        const errorCount = findings.filter((f) => f.severity === "error").length;
+        const warnCount = findings.filter((f) => f.severity === "warning").length;
+        const infoCount = findings.filter((f) => f.severity === "info").length;
         ctx.output.info(`\n${total} finding${total !== 1 ? "s" : ""}: ${errorCount} error${errorCount !== 1 ? "s" : ""}, ${warnCount} warning${warnCount !== 1 ? "s" : ""}, ${infoCount} info`);
         if (errorCount > 0) {
             throw new Error(`Lint failed with ${errorCount} error${errorCount !== 1 ? "s" : ""}`);

package/dist/commands/pattern.js

@@ -0,0 +1,55 @@
+import { ALL_PATTERNS, findPattern } from "@bpmnkit/patterns";
+const listCmd = {
+    name: "list",
+    description: "List the built-in domain process patterns",
+    examples: [{ description: "List all patterns", command: "casen pattern list" }],
+    async run(ctx) {
+        ctx.output.print(ALL_PATTERNS.map((p) => ({
+            id: p.id,
+            name: p.name,
+            description: p.description,
+            keywords: p.keywords,
+        })));
+    },
+};
+const getCmd = {
+    name: "get",
+    description: "Show a domain pattern's full context: readme, worker specs, and variations",
+    args: [
+        {
+            name: "query",
+            description: "Pattern id (e.g. invoice-approval) or a free-text description to match",
+            required: true,
+        },
+    ],
+    examples: [
+        { description: "By id", command: "casen pattern get invoice-approval" },
+        { description: "By description", command: 'casen pattern get "employee onboarding"' },
+    ],
+    async run(ctx) {
+        const query = ctx.positional.join(" ");
+        if (!query)
+            throw new Error("Missing required argument: <query>");
+        const pattern = findPattern(query);
+        if (!pattern) {
+            ctx.output.info(`No pattern matched "${query}". Run \`casen pattern list\` to see all patterns.`);
+            return;
+        }
+        ctx.output.print({
+            id: pattern.id,
+            name: pattern.name,
+            description: pattern.description,
+            readme: pattern.readme,
+            workers: pattern.workers,
+            variations: pattern.variations,
+            note: "`template` is a rough structural reference in an older compact-diagram shape, not a ProcessPlan — use the readme/workers as context when writing your own plan, don't paste the template in as-is.",
+            template: pattern.template,
+        });
+    },
+};
+export const patternGroup = {
+    name: "pattern",
+    description: "Look up built-in domain process patterns for AI-driven process generation",
+    commands: [listCmd, getCmd],
+};
+//# sourceMappingURL=pattern.js.map

package/dist/commands/plan.js

@@ -0,0 +1,70 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Bpmn, extractPlan } from "@bpmnkit/core";
+const extractCmd = {
+    name: "extract",
+    description: "Lift an existing .bpmn file back into ProcessPlan JSON form",
+    args: [{ name: "file", description: "Path to the .bpmn file", required: true }],
+    flags: [
+        {
+            name: "output",
+            short: "o",
+            description: "Output .json file path (default: <file>.plan.json)",
+            type: "string",
+        },
+    ],
+    examples: [{ description: "Extract a plan", command: "casen plan extract order-process.bpmn" }],
+    async run(ctx) {
+        const filePath = ctx.positional[0];
+        if (!filePath)
+            throw new Error("Missing required argument: <file>");
+        const xml = await readFile(resolve(filePath), "utf-8");
+        const defs = Bpmn.parse(xml);
+        const { plan, unsupported } = extractPlan(defs);
+        const outputPath = resolve(typeof ctx.flags.output === "string"
+            ? ctx.flags.output
+            : `${filePath.replace(/\.bpmn$/, "")}.plan.json`);
+        await writeFile(outputPath, `${JSON.stringify(plan, null, "\t")}\n`, "utf-8");
+        ctx.output.ok(`Wrote ${outputPath}`);
+        if (unsupported.length > 0) {
+            ctx.output.info(`\n${unsupported.length} element(s) could not be lifted — left out of the plan, not guessed at:`);
+            for (const u of unsupported)
+                ctx.output.info(`  [${u.id}] (${u.type}) ${u.reason}`);
+        }
+    },
+};
+export const PLAN_SCHEMA_SUMMARY = `ProcessPlan (version 1)
+{
+  "version": 1,
+  "process": { "id": string, "name"?: string, "versionTag"?: string },
+  "inputs"?: [{ "name": string, "type": string, "required"?: boolean, "description"?: string }],
+  "steps": PlanStep[],
+  "tests"?: PlanScenario[]
+}
+
+PlanStep.kind: "start" | "connector" | "serviceTask" | "userTask" | "businessRuleTask" |
+  "scriptTask" | "sendTask" | "receiveTask" | "callActivity" | "aiAgent" | "gateway" |
+  "subProcess" | "wait" | "end" | "raw"
+
+Every step: { id?, name?, documentation?, errorBoundary?: { errorCode, steps }, timerBoundary?: {...} }
+FEEL convention: a leading "=" makes a string a FEEL expression; without it, the value is literal.
+
+steps[0] must be kind "start". "gateway" steps carry { gatewayType, branches: [{ condition?, default?, steps }] }.
+"connector"/"aiAgent" tool steps reference a bundled Camunda template via { template, values } —
+see \`casen connector search <query>\` / \`casen connector show <templateId>\` for available templates
+and their required/optional input keys.
+
+Full type definitions: packages/core/src/plan/types.ts in the bpmnkit monorepo.`;
+const schemaCmd = {
+    name: "schema",
+    description: "Print the ProcessPlan format reference",
+    async run(ctx) {
+        ctx.output.info(PLAN_SCHEMA_SUMMARY);
+    },
+};
+export const planGroup = {
+    name: "plan",
+    description: "ProcessPlan authoring — extract an existing process, or print the plan format reference",
+    commands: [extractCmd, schemaCmd],
+};
+//# sourceMappingURL=plan.js.map

package/dist/commands/skills.js

@@ -4,7 +4,8 @@ import { fileURLToPath } from "node:url";
 /**
  * Install BPMNKit AIKit skills into `.claude/commands/` in the current project.
  * Skills are markdown prompt files that Claude Code executes as slash commands:
- *   /design, /implement, /review, /test, /deploy
+ *   /implement, /review, /test, /deploy
+ * Lightweight, CLI-only versions of the full plugin's skill set — see aikit.md.
  *
  * Also installs aikit.md into .claude/ as a shared tool reference.
  */
@@ -84,7 +85,10 @@ const skillsInstallCmd = {
             ctx.output.info(`  /${name}`);
         }
         ctx.output.info("");
-        ctx.output.info("Make sure the BPMNKit AIKit MCP server is configured in .claude/mcp.json");
+        ctx.output.info("These commands drive `casen` directly — no MCP server or proxy needed. " +
+            "For the full skill set (implement/extend/agent/connect/review/test/deploy + generated " +
+            "reference docs), install the Claude Code plugin instead: " +
+            "/plugin marketplace add github:bpmnkit/monorepo && /plugin install bpmnkit");
     },
 };
 export const skillsGroup = {