@bpmnkit/cli 0.0.36 → 0.0.37

package/README.md

@@ -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/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 = {

package/dist/commands/synth.js

@@ -0,0 +1,103 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { applyConnectorTemplate } from "@bpmnkit/connectors";
+import { Bpmn, compilePlan, mergePlan, slugify, uniqueId } from "@bpmnkit/core";
+async function readPlan(path) {
+    const text = await readFile(resolve(path), "utf-8");
+    return JSON.parse(text);
+}
+/** Convert plan-embedded test scenarios to the `.bpmn.tests.json` shape consumed by `casen test`. */
+export function toScenarioSidecar(tests) {
+    const taken = new Set();
+    return tests.map((t) => {
+        const id = uniqueId(slugify(t.name), taken);
+        const mocks = Object.fromEntries(Object.entries(t.mocks ?? {}).map(([jobType, mock]) => [
+            jobType,
+            "error" in mock
+                ? {
+                    error: mock.error.message
+                        ? `${mock.error.code}: ${mock.error.message}`
+                        : mock.error.code,
+                }
+                : { outputs: mock.outputs },
+        ]));
+        return { id, name: t.name, inputs: t.inputs, mocks, expect: t.expect };
+    });
+}
+const synthCmd = {
+    name: "synth",
+    description: "Compile a ProcessPlan JSON file into deployable, laid-out BPMN XML",
+    args: [{ name: "plan", description: "Path to the ProcessPlan JSON file", required: true }],
+    flags: [
+        {
+            name: "output",
+            short: "o",
+            description: "Output .bpmn file path (default: <plan>.bpmn)",
+            type: "string",
+        },
+        {
+            name: "merge",
+            description: "Merge into an existing .bpmn file instead of creating a new one",
+            type: "string",
+        },
+        {
+            name: "json",
+            description: "Print the result (problems + xml) as JSON instead of writing a file",
+            type: "boolean",
+        },
+    ],
+    examples: [
+        { description: "Compile a plan to BPMN", command: "casen synth order-process.plan.json" },
+        {
+            description: "Extend an existing process",
+            command: "casen synth delta.plan.json --merge order-process.bpmn",
+        },
+    ],
+    async run(ctx) {
+        const planPath = ctx.positional[0];
+        if (!planPath)
+            throw new Error("Missing required argument: <plan>");
+        const plan = await readPlan(planPath);
+        const mergeTarget = typeof ctx.flags.merge === "string" ? ctx.flags.merge : undefined;
+        const result = mergeTarget
+            ? mergePlan(Bpmn.parse(await readFile(resolve(mergeTarget), "utf-8")), plan, {
+                resolveConnector: applyConnectorTemplate,
+            })
+            : compilePlan(plan, { resolveConnector: applyConnectorTemplate });
+        if (ctx.flags.json) {
+            ctx.output.print(result);
+            if (!result.xml)
+                process.exitCode = 1;
+            return;
+        }
+        if (result.problems.length > 0) {
+            for (const p of result.problems)
+                ctx.output.info(`✖ [${p.path}] ${p.message}`);
+        }
+        if (!result.xml) {
+            throw new Error(`Compilation failed with ${result.problems.length} problem(s) — see above`);
+        }
+        const outputPath = resolve(typeof ctx.flags.output === "string"
+            ? ctx.flags.output
+            : (mergeTarget ?? planPath.replace(/\.json$/, ".bpmn")));
+        await writeFile(outputPath, result.xml, "utf-8");
+        if (plan.tests && plan.tests.length > 0) {
+            const sidecarPath = `${outputPath}.tests.json`;
+            await writeFile(sidecarPath, JSON.stringify(toScenarioSidecar(plan.tests), null, 2), "utf-8");
+            ctx.output.info(`Wrote ${sidecarPath} (${plan.tests.length} scenario(s) — run: casen test ${outputPath})`);
+        }
+        if (result.problems.length > 0) {
+            ctx.output.info(`\nWrote ${outputPath} with ${result.problems.length} problem(s) above.`);
+            process.exitCode = 1;
+        }
+        else {
+            ctx.output.ok(`Wrote ${outputPath}`);
+        }
+    },
+};
+export const synthGroup = {
+    name: "synth",
+    description: "Compile a ProcessPlan into deployable BPMN — the deterministic AI-generation pipeline",
+    commands: [synthCmd],
+};
+//# sourceMappingURL=synth.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/cli",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "description": "Command-line interface for Camunda 8 — deploy, manage, and monitor processes from the terminal",
   "type": "module",
   "bin": {
@@ -16,13 +16,15 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@bpmnkit/api": "0.0.19",
-    "@bpmnkit/ascii": "0.0.29",
-    "@bpmnkit/connector-gen": "0.0.14",
-    "@bpmnkit/core": "0.1.1",
-    "@bpmnkit/engine": "0.1.29",
-    "@bpmnkit/profiles": "0.0.17",
-    "@bpmnkit/proxy": "0.0.32"
+    "@bpmnkit/api": "0.0.20",
+    "@bpmnkit/ascii": "0.0.30",
+    "@bpmnkit/connector-gen": "0.0.15",
+    "@bpmnkit/connectors": "0.0.2",
+    "@bpmnkit/core": "0.1.2",
+    "@bpmnkit/engine": "0.1.30",
+    "@bpmnkit/patterns": "0.0.5",
+    "@bpmnkit/profiles": "0.0.18",
+    "@bpmnkit/proxy": "0.0.33"
   },
   "publishConfig": {
     "access": "public"

package/skills/aikit.md

@@ -1,267 +1,46 @@
-# BPMNKit AIKit — Tool Reference
+# BPMNKit — Reference
 
-This file is installed to `.claude/aikit.md` by `casen skills install`.
-The skill files (`/design`, `/implement`, etc.) reference it with `@.claude/aikit.md`.
+This file is installed to `.claude/aikit.md` by `casen skills install`. The skill files (`/implement`, `/review`, `/test`, `/deploy`) reference it with `@.claude/aikit.md`.
 
----
-
-## MCP server
-
-All tools are exposed by the `bpmnkit-aikit` MCP server configured in `.claude/mcp.json`.
-Tool names follow the pattern `mcp__bpmnkit-aikit__<tool_name>`.
-
----
-
-## BPMN tools
-
-### `bpmn_create`
-
-Generate a new BPMN process from a natural language description.
-
-- Automatically loads a matching domain pattern for context before calling the AI.
-- Writes the `.bpmn` file to disk.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `description` | yes | Natural language description of the process. Include actors, decision points, and expected outcomes. The richer the description, the better the diagram. |
-| `outputDir` | no | Directory to write the file (default: current working directory). |
-
-**Returns** `{ path: string, patternMatched: string | null }`
-
-**Good description example:**
-> "Invoice approval process with a clerk review step, automatic approval under €500, manager approval for higher amounts, and email notification on rejection."
-
----
-
-### `bpmn_read`
-
-Read a BPMN file and return its compact JSON representation.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `path` | yes | Path to the `.bpmn` file. |
-
-**Returns** Compact JSON with shape:
-```json
-{
-  "id": "process-id",
-  "processes": [{
-    "id": "...", "name": "...",
-    "elements": [
-      { "type": "startEvent", "id": "...", "name": "..." },
-      { "type": "serviceTask", "id": "...", "name": "...", "jobType": "com.example:do-thing:1" },
-      { "type": "userTask", "id": "...", "name": "...", "formId": "approve-form" },
-      { "type": "businessRuleTask", "id": "...", "name": "...", "decisionId": "credit-check" },
-      { "type": "exclusiveGateway", "id": "...", "name": "..." },
-      { "type": "endEvent", "id": "...", "name": "..." }
-    ]
-  }]
-}
-```
-
-Use `jobType` to identify service tasks for worker scaffolding. Use `formId` / `decisionId` to know which tasks need forms/DMN tables.
-
----
-
-### `bpmn_update`
-
-Update an existing BPMN by describing the change in natural language.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `path` | yes | Path to the `.bpmn` file. |
-| `instruction` | yes | What to change, e.g. "Add an error boundary event on the payment task that routes to a manual review lane." |
-
-**Returns** `{ path: string, updated: true }`
-
----
-
-### `bpmn_validate`
-
-Validate a BPMN file using the BPMNKit pattern advisor.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `path` | yes | Path to the `.bpmn` file. |
-
-**Returns**
-```json
-{
-  "summary": { "total": 3, "errors": 1, "warnings": 1, "info": 1, "autoFixable": 2 },
-  "findings": [
-    {
-      "severity": "error" | "warning" | "info",
-      "category": "string",
-      "message": "string",
-      "suggestion": "string",
-      "elementIds": ["..."],
-      "autoFixable": true
-    }
-  ]
-}
-```
-
-Errors block deployment. Warnings and info are advisory.
-
----
-
-### `bpmn_deploy`
-
-Deploy a BPMN process to a running engine.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `path` | yes | Path to the `.bpmn` file. |
-| `target` | yes | `"local"` — local reebe instance (uses `ZEEBE_ADDRESS`). `"camunda8"` — active Camunda 8 profile (set with `casen profile create`). |
-
-**Returns** `{ success: true, target: string, result: object }`
-
----
-
-### `bpmn_simulate`
-
-Structural analysis: validation findings + worker coverage check.
-
-> **Note:** Phase 1 only — structural analysis. Full process execution simulation is planned for a future phase.
+These are lightweight, CLI-only slash commands. For the full skill set — `/bpmnkit:implement`, `/bpmnkit:extend`, `/bpmnkit:agent`, `/bpmnkit:connect`, plus generated reference docs (`plan-format.md`, `connectors.md`, `agentic.md`, `feel.md`) — install the Claude Code plugin instead:
 
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `path` | yes | Path to the `.bpmn` file. |
-
-**Returns**
-```json
-{
-  "validation": { "errors": 0, "findings": [] },
-  "workerCoverage": {
-    "total": 3,
-    "covered": 2,
-    "missing": ["com.example:send-invoice:1"]
-  }
-}
+```sh
+/plugin marketplace add github:bpmnkit/monorepo
+/plugin install bpmnkit
 ```
 
 ---
 
-### `bpmn_run_history`
-
-Query recent process executions from the local proxy.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `processId` | no | Filter by process definition ID. |
-
-**Returns** `{ runs: [...] }` — up to 20 recent executions.
-
----
-
-## Worker tools
-
-### `worker_list`
-
-List all available workers: built-in BPMNKit workers and any scaffolded workers found in `./workers/`.
-
-**Parameters** none
-
-**Returns** `{ workers: [{ jobType, name, description, ... }], total: number }`
-
----
-
-### `worker_scaffold`
-
-Scaffold a TypeScript worker for a Zeebe job type. Generates `index.ts`, `package.json`, `tsconfig.json`, `README.md` in `./workers/<slug>/`.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `jobType` | yes | Zeebe job type string, e.g. `com.example:send-invoice:1`. |
-| `description` | no | What this worker does. |
-| `inputs` | no | Object mapping input variable names to type descriptions, e.g. `{ "invoiceId": "string", "amount": "number" }`. |
-| `outputs` | no | Object mapping output variable names to type descriptions. |
-
-**Returns** `{ path: string, files: [...], jobType: string, note: string }`
-
-After scaffolding: `cd workers/<slug> && npm install && npm start`. Edit `index.ts` to implement `handle()`.
-
----
-
-## Form & DMN tools
-
-### `form_create`
-
-Generate Camunda form JSON for all `userTask` elements in a BPMN that have a `formId`. Writes one `.form` file per task.
+## The pipeline
 
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `bpmnPath` | yes | Path to the `.bpmn` file. |
-| `outputDir` | no | Where to write form files (default: same directory as the BPMN). |
+Every process is authored as a `ProcessPlan` JSON file, never hand-written BPMN XML:
 
-**Returns**
-```json
-{
-  "forms": [
-    { "taskId": "...", "taskName": "...", "formId": "...", "path": "path/to/form-id.form" }
-  ]
-}
 ```
-
-Returns `{ "forms": [] }` if no user tasks with `formId` are found.
-
----
-
-### `dmn_create`
-
-Generate DMN decision table XML for all `businessRuleTask` elements in a BPMN that have a `decisionId`. Writes one `.dmn` file per task.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `bpmnPath` | yes | Path to the `.bpmn` file. |
-| `outputDir` | no | Where to write DMN files (default: same directory as the BPMN). |
-
-**Returns**
-```json
-{
-  "decisions": [
-    { "taskId": "...", "taskName": "...", "decisionId": "...", "path": "path/to/decision-id.dmn" }
-  ]
-}
+<name>.plan.json  →  casen synth  →  <name>.bpmn (+ <name>.bpmn.tests.json if plan.tests is set)
 ```
 
-Returns `{ "decisions": [] }` if no business rule tasks with `decisionId` are found.
-
----
-
-## Pattern tools
-
-### `pattern_list`
-
-List all available domain process patterns.
-
-**Parameters** none
-
-**Returns** `{ patterns: [{ id, name, description, keywords }], total: number }`
-
-Call this at the start of any skill to check whether a domain pattern applies. Match by comparing keywords against the user's request.
-
----
-
-### `pattern_get`
-
-Get the full content of a domain pattern: readme, worker specs, variations, and a compact BPMN template.
-
-**Parameters**
-| Name | Required | Description |
-|---|---|---|
-| `domain` | yes | Pattern id (e.g. `"invoice-approval"`) or free-text query (e.g. `"employee onboarding"`). |
-
-**Returns** `{ id, name, description, keywords, readme, workers, variations, template }`
-
-Pass `pattern.readme` and `pattern.workers` as additional context in the `description` parameter of `bpmn_create`.
+`casen plan schema` prints the full `ProcessPlan` format reference. `casen plan extract <file>.bpmn` lifts an existing process back into plan form (for `/extend`-style changes).
+
+## Key commands
+
+| Command | Does |
+|---|---|
+| `casen plan schema` | Print the `ProcessPlan` JSON format reference |
+| `casen plan extract <file>.bpmn` | Lift an existing process into `<file>.plan.json` |
+| `casen synth <plan>.json --output <file>.bpmn` | Compile a plan to laid-out, deployable BPMN |
+| `casen synth <plan>.json --merge <file>.bpmn --output <file>.bpmn` | Compile a delta plan and merge it into an existing process |
+| `casen connector search "<query>"` | Find a Camunda connector template by name/keyword |
+| `casen connector show <template-id>` | Required/optional input keys, task type, direction |
+| `casen lint lint <file>.bpmn` | Full static analysis (all categories) |
+| `casen lint lint <file>.bpmn --profile deploy` | Deploy-readiness gate — errors only |
+| `casen lint lint <file>.bpmn --fix` | Apply auto-fixable findings, write back |
+| `casen test <file>.bpmn` | Run scenarios from `<file>.bpmn.tests.json` |
+| `casen deploy deploy <file>.bpmn [--target camunda8]` | Deploy to local Reebe (default) or Camunda 8 |
+| `casen worker start` | Start every scaffolded worker in `./workers/` |
+
+## Conventions
+
+- A value starting with `=` is a FEEL expression; without it, it's a literal string.
+- Secrets always use the `{{secrets.NAME}}` placeholder — never a literal credential.
+- Every plan step's `id`/`name` should follow Camunda naming conventions ("Verb Object" tasks, "Object + past participle" start events, "?" gateway questions) — see the full plugin's `references/modeling-style.md` for the complete list.
+- Worker stubs use `@bpmnkit/worker-client`'s `createWorkerClient({ workerName }).poll(jobType)` API, written to `workers/<slug>/index.ts`.

package/skills/deploy.md

@@ -1,33 +1,36 @@
 ---
-description: Deploy a BPMN process to local reebe or Camunda 8
+description: Gate a BPMN process on deploy-readiness, then deploy it to local Reebe or Camunda 8.
 ---
 
 @.claude/aikit.md
 
-Deploy the BPMN process at the given path.
+Deploy the BPMN process: $ARGUMENTS
 
-## File to deploy
+Extract the `.bpmn` filename (find the single `.bpmn` in cwd, or ask, if not given) and destination (`--local` default, or `--camunda`).
 
-$ARGUMENTS
+## Step 1 — Gate on deploy-readiness
 
----
+```sh
+casen lint lint <file>.bpmn --profile deploy
+```
+
+If this reports any errors, stop and fix them first (or run `/review`) — do not deploy with deploy-profile errors.
+
+## Step 2 — Deploy
+
+```sh
+casen deploy deploy <file>.bpmn                     # local Reebe
+casen deploy deploy <file>.bpmn --target camunda8   # active Camunda 8 profile
+```
 
-1. Call `mcp__bpmnkit-aikit__bpmn_validate` on the file to check for errors before deploying.
-   - If there are errors, show them and ask: **"Fix errors first or deploy anyway?"**
-   - If warnings only: show them but proceed.
+Local deploy unreachable → tell the user to run `casen reebe start --port 26500` first, then retry. Camunda 8 deploy with no active profile → tell the user to run `casen profile create <name> --base-url <url> --auth-type bearer --token <token>` then `casen profile use <name>`, then retry.
 
-2. Ask: **"Deploy to local reebe or Camunda 8?"**
+## Step 3 — Verify and summarize
 
-3. Call `mcp__bpmnkit-aikit__bpmn_deploy` with the chosen target:
-   - `"local"` — deploys to the local reebe instance at ZEEBE_ADDRESS
-   - `"camunda8"` — deploys using the active casen profile (run `casen profile create` if not set up)
+```sh
+casen process-definition list --output json
+```
 
-4. Report the result:
-   - On success: "Deployed successfully. Process ID: <id>"
-   - On failure: show the error and suggest a fix (profile not set up, reebe not running, etc.)
+Report: `Deployed: <process-id>  version: <N>  target: <local|camunda8>`.
 
-5. If any scaffolded workers exist in ./workers/, remind:
-   ```
-   Don't forget to start your workers:
-     casen worker start
-   ```
+If any scaffolded workers exist in `./workers/`, remind: `casen worker start`. Remind about any `{{secrets.NAME}}` the process references — they must be provisioned in the target engine's secret store.

package/skills/implement.md

@@ -1,10 +1,10 @@
 ---
-description: Implement a BPMN process end-to-end from a natural language description
+description: Implement a BPMN process end-to-end from a natural language description — plan, compile, test, deploy.
 ---
 
 @.claude/aikit.md
 
-You are implementing a BPMN process end-to-end using BPMNKit AIKit tools. Work through these steps in order.
+You are implementing a BPMN process using `casen`. You never write BPMN XML by hand — every process is authored as a `ProcessPlan` JSON file and compiled with `casen synth`.
 
 ## Request
 
@@ -12,82 +12,48 @@ $ARGUMENTS
 
 ---
 
-## Step 1 — Check for a domain pattern
+## Step 1 — Resolve external interactions
 
-Call `mcp__bpmnkit-aikit__pattern_list` to see available domain patterns.
-If any pattern keywords match the request, call `mcp__bpmnkit-aikit__pattern_get` to load the full pattern as context for the next step.
+For each external system the process touches (Slack, email, HTTP, etc.): `casen connector search "<system>"` then `casen connector show <template-id>` for its required inputs. No match → use a plain `jobType` step (a worker gets scaffolded in Step 5).
 
----
-
-## Step 2 — Plan: Create the BPMN
-
-Spawn a subagent with this task:
+## Step 2 — Write the plan
 
-> Using the MCP tool `mcp__bpmnkit-aikit__bpmn_create`, generate a BPMN process for: **$ARGUMENTS**
->
-> If a domain pattern was loaded in Step 1, pass its readme and worker specs as additional context in the description parameter.
->
-> Return the file path of the generated BPMN.
-
----
+Write `<slug>.plan.json` per `casen plan schema`. Name elements clearly (see `.claude/aikit.md`'s naming conventions).
 
-## Step 3 — Implement: Wire workers
-
-Spawn a subagent with this task:
-
-> You are implementing workers for a BPMN process.
->
-> 1. Call `mcp__bpmnkit-aikit__worker_list` to get the catalog of available workers.
-> 2. Call `mcp__bpmnkit-aikit__bpmn_read` on the BPMN file from Step 2 to find all service task job types.
-> 3. For each service task job type:
->    - If a built-in or previously scaffolded worker matches: note it as "reused"
->    - If no match exists: call `mcp__bpmnkit-aikit__worker_scaffold` with the job type, a description, and expected inputs/outputs derived from the BPMN context
-> 4. Return: a list of `{ jobType, status: "reused" | "scaffolded", workerPath? }` for each service task
-
----
+## Step 3 — Compile
 
-## Step 4 — Review: Validate the BPMN
-
-Spawn a subagent with this task:
+```sh
+casen synth <slug>.plan.json --output <slug>.bpmn
+```
 
-> Call `mcp__bpmnkit-aikit__bpmn_validate` on the BPMN file from Step 2.
-> Identify any errors that block deployment and any warnings worth noting.
-> Return: `{ errors: [...], warnings: [...] }`
+Fix any reported problems in the plan (never the XML) and re-run — bounded to 2 retries before asking the user.
 
----
+## Step 4 — Test
 
-## Step 5 — Test: Check coverage
+Add a `tests` array to the plan covering the happy path and every branch/boundary, re-synth (writes `<slug>.bpmn.tests.json`), then:
 
-Spawn a subagent with this task:
+```sh
+casen test <slug>.bpmn
+```
 
-> Call `mcp__bpmnkit-aikit__bpmn_simulate` on the BPMN file from Step 2 with an empty scenarios array.
-> Return: worker coverage report (total service tasks, covered, missing)
+## Step 5 — Scaffold workers
 
----
+For every job-type step with no existing worker, write `workers/<slug>/index.ts` using `@bpmnkit/worker-client`'s `createWorkerClient({ workerName }).poll(jobType)` API.
 
 ## Step 6 — Present summary and ask to deploy
 
-Collect all results and present a summary:
-
 ```
 BPMN file: <path>
-Pattern used: <id or "none">
-
-Workers:
-  ✓ reused:     <list>
-  + scaffolded: <list with paths>
-
-Validation:
-  Errors:   <count> — <list if any>
-  Warnings: <count> — <list if any>
 
-Worker coverage: <covered>/<total> service tasks
+Connectors used: <list, with required secrets — never their values>
+Workers: reused <list> / scaffolded <list with paths>
+Tests: X/Y passed
 
 Scaffolded workers require: npm install && npm start (in each workers/<name>/ directory)
 ```
 
-Then ask: **"Deploy to local reebe, deploy to Camunda 8, or skip deployment?"**
+Then ask: **"Deploy to local Reebe, deploy to Camunda 8, or skip?"**
 
-- If "local": call `mcp__bpmnkit-aikit__bpmn_deploy` with `target: "local"`
-- If "camunda8": call `mcp__bpmnkit-aikit__bpmn_deploy` with `target: "camunda8"`
-- If "skip": done
+- local: `casen lint lint <slug>.bpmn --profile deploy` (must be zero errors) then `casen deploy deploy <slug>.bpmn`
+- camunda8: same lint gate, then `casen deploy deploy <slug>.bpmn --target camunda8`
+- skip: done

package/skills/review.md

@@ -1,35 +1,41 @@
 ---
-description: Review a BPMN file and report findings with severity and fix suggestions
+description: Review a BPMN file and report findings with severity and an explicit deploy-ready verdict.
 ---
 
 @.claude/aikit.md
 
-Review the BPMN file at the given path using BPMNKit's pattern advisor.
+Review the BPMN file: $ARGUMENTS
 
-## File to review
+If no file is given, find the single `.bpmn` in cwd or ask.
 
-$ARGUMENTS
+## Step 1 — Run both profiles
 
----
+```sh
+casen lint lint <file>.bpmn --profile deploy --format json
+casen lint lint <file>.bpmn --format json
+```
 
-1. Call `mcp__bpmnkit-aikit__bpmn_validate` on the path above.
+## Step 2 — Present findings grouped by severity
 
-2. Present findings grouped by severity:
+**Errors** (must fix before deploy)
+- `[element-id]` `[category]` message. Fix: suggestion, if present.
 
-**Errors** (block deployment or indicate broken process flow)
-- For each error: element IDs, message, suggested fix
+**Warnings** (should fix)
+- ...
 
-**Warnings** (best-practice violations, missing patterns)
-- For each warning: element IDs, message, suggested fix
+**Info** (consider)
+- ...
 
-**Info** (improvement suggestions)
-- For each info item: message
+## Step 3 — Offer auto-fix
 
-3. Show a summary:
-```
-Total: <n> findings — <errors> errors, <warnings> warnings, <info> info
-Auto-fixable: <n>
+If there are any findings, offer:
+
+```sh
+casen lint lint <file>.bpmn --fix
 ```
 
-4. If there are auto-fixable findings, ask: **"Apply auto-fixes?"**
-   If yes, call `mcp__bpmnkit-aikit__bpmn_update` with instruction: "Apply all auto-fixable pattern advisor suggestions"
+Re-run Step 1 afterward to confirm.
+
+## Step 4 — Explicit verdict
+
+End with: **"Deploy-ready: yes"** (zero errors from the deploy profile) or **"Deploy-ready: no — N error(s)"**.

package/skills/test.md

@@ -1,38 +1,36 @@
 ---
-description: Analyse a BPMN process — check worker coverage and validation findings
+description: Run scenario tests on a BPMN process file and report path coverage.
 ---
 
 @.claude/aikit.md
 
-Analyse the BPMN process at the given path.
+Run scenario tests: $ARGUMENTS
 
-## File to test
+If no file is given, find the single `.bpmn` in cwd or ask.
 
-$ARGUMENTS
+## Step 1 — Ensure scenarios exist
 
----
+Look for `<file>.bpmn.tests.json` (written automatically by `casen synth` from a plan's `tests` array). If missing: `casen plan extract <file>.bpmn`, add a `tests` array covering the happy path and every branch/boundary, then `casen synth <plan>.json --merge <file>.bpmn` to regenerate it — or hand-write the sidecar directly (array of `{ id, name, inputs?, mocks?, expect? }`).
 
-1. Call `mcp__bpmnkit-aikit__bpmn_read` to understand the process structure (elements, service tasks, gateways, event types).
+## Step 2 — Run
 
-2. Call `mcp__bpmnkit-aikit__bpmn_simulate` with the path and an empty scenarios array to get worker coverage and validation analysis.
+```sh
+casen test <file>.bpmn
+```
 
-3. Call `mcp__bpmnkit-aikit__worker_list` to show the full worker catalog.
+## Step 3 — Report
 
-4. Present the results:
+```
+| Scenario | Result | Details |
+|----------|--------|---------|
+| happy-path | ✓ PASS | (Nms) |
+| error-path | ✗ FAIL | field: expected X, got Y |
+```
 
-**Process structure**
-- Pools / participants
-- Service tasks and their job types
-- Decision gateways and branch conditions
-- Event types (timer, message, error, escalation)
+## Step 4 — Coverage
 
-**Worker coverage**
-- ✓ Covered job types (matched to built-in or scaffolded workers)
-- ✗ Missing job types (no worker found — scaffold with worker_scaffold)
+Cross-reference gateway branches and error/timer boundaries against which scenarios exercise them; report anything uncovered.
 
-**Validation findings**
-- Errors and warnings from the pattern advisor
+## Step 5 — Summary
 
-**Suggested test scenarios** (derived from the BPMN structure)
-- Happy path: <describe the main success path>
-- Edge cases: <describe key branches, timeouts, error conditions>
+"X/Y scenarios passed. N branch(es)/boundary(ies) uncovered."

package/skills/design.md

@@ -1,87 +0,0 @@
----
-description: Design a BPMN process — flow, forms, and decision tables. No workers, no deployment.
----
-
-@.claude/aikit.md
-
-You are designing a BPMN process using BPMNKit AIKit tools. Work through these steps in order.
-
-## Request
-
-$ARGUMENTS
-
----
-
-## Step 1 — Check for a domain pattern
-
-Call `mcp__bpmnkit-aikit__pattern_list` to see available domain patterns.
-If any pattern keywords match the request, call `mcp__bpmnkit-aikit__pattern_get` to load the full pattern as context.
-
----
-
-## Step 2 — Create the BPMN
-
-Spawn a subagent with this task:
-
-> Using `mcp__bpmnkit-aikit__bpmn_create`, generate a BPMN process for: **$ARGUMENTS**
->
-> If a pattern was loaded in Step 1, pass its readme and worker specs as context in the description parameter.
->
-> Return the file path of the generated BPMN.
-
----
-
-## Step 3 — Generate forms
-
-Spawn a subagent with this task:
-
-> Call `mcp__bpmnkit-aikit__form_create` with the BPMN path from Step 2.
->
-> Return: list of `{ taskId, formId, path }` for each form created, or an empty list if no user tasks with formId were found.
-
----
-
-## Step 4 — Generate DMN tables
-
-Spawn a subagent with this task:
-
-> Call `mcp__bpmnkit-aikit__dmn_create` with the BPMN path from Step 2.
->
-> Return: list of `{ taskId, decisionId, path }` for each DMN file created, or an empty list if no business rule tasks with decisionId were found.
-
----
-
-## Step 5 — Validate
-
-Spawn a subagent with this task:
-
-> Call `mcp__bpmnkit-aikit__bpmn_validate` on the BPMN file from Step 2.
->
-> Return: `{ errors: [...], warnings: [...] }`
-
----
-
-## Step 6 — Present design summary
-
-Collect all results and present:
-
-```
-BPMN:    <path>
-Pattern: <id or "none">
-
-Forms (<count>):
-  <formId> → <path>
-  (or "none" if empty)
-
-DMN tables (<count>):
-  <decisionId> → <path>
-  (or "none" if empty)
-
-Validation:
-  Errors:   <count> — <list if any>
-  Warnings: <count> — <list if any>
-```
-
-Then say: **"Use `/implement` to add workers, or `/deploy` when ready."**
-
-Do NOT offer to deploy.