@bpmnkit/docspack 0.0.4 → 0.0.6

package/.llms/chunks/guides.ai.minimal-empty-diagram.md

@@ -24,6 +24,7 @@ Rules:
 - Use camelCase IDs
 - Every service task needs a taskType string (the Zeebe worker subscription)
 - Use FEEL expressions for gateway conditions (start with "= ")
+- Every exclusive gateway needs one branch with no condition and `isDefault: true`
 - Always include a start event and at least one end event
 - Do not add fields that are not part of the CompactDiagram schema
 ```

package/.llms/chunks/guides.using-bpmnkit-with-ai.asking.md

@@ -0,0 +1,47 @@
+# Using BPMN Kit with AI — Asking
+
+```sh
+npx bpmnkit-docs ask "what does compactify drop from a diagram"
+```
+
+```
+## @bpmnkit/docspack@0.0.5/packages.core.installation-compactify-definitions
+
+Projects a `BpmnDefinitions` object onto a `CompactDiagram` — a small JSON
+object suitable for LLM prompts. **Lossy:** it keeps topology, names …
+
+---
+cost: 204 tokens, capped at 3,000
+```
+
+Every answer names the pack, the version and the chunk, and closes with what it
+cost — so an agent can quote the chunk id back when a passage turns out to be
+wrong.
+
+Ask the engine's documentation with `--pack`:
+
+```sh
+npx bpmnkit-docs ask "what happens when no exclusive gateway condition is true" \
+  --pack @bpmnkit/camunda-docspack
+```
+
+`--pack` is worth using even when you are not disambiguating. Building the index
+reads every chunk off disk, so narrowing to one pack is the difference between
+roughly 150ms and 650ms per question. A name that is not installed is an error
+listing what is, never an empty answer — an empty answer would read as "the
+documentation does not cover this", which is a different claim.
+
+`search` ranks without printing the content, and `list` shows what was found:
+
+```sh
+npx bpmnkit-docs search "exclusive gateway condition"
+npx bpmnkit-docs list
+```
+
+```
+@bpmnkit/camunda-docspack@0.1.1  1054 chunks
+@bpmnkit/docspack@0.0.5  206 chunks
+```
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli-the-other-route-docspack-index.md

@@ -0,0 +1,56 @@
+# Using BPMN Kit with AI — From the library instead of the CLI — The other route: `docspack index`
+
+Upstream [docspack](https://docspack.dev) 1.1.0 added
+[a second way to do this](https://docspack.dev/docs/your-own-corpus/). Rather than
+building a pack, it keeps an SQLite index of loose sources, and answers from it
+with `recall` instead of `ask`:
+
+```sh
+npm i -D docspack
+
+npx docspack index --from ./flow-docs
+npx docspack recall "when does an order need manager approval"
+```
+
+```
+indexing @local/flow-docs
++ @local/flow-docs  10 chunks  ~527 tokens
+```
+
+Pick it over `bpmnkit-docs build` when the corpus is not a folder of Markdown.
+Anything that emits JSON can be indexed without a database driver:
+
+```sh
+sqlite3 -json shop.db 'select id, title, body as text from orders'   | npx docspack index --from-json -
+```
+
+It also tracks each source's size, mtime and hash, so a re-run does nothing when
+nothing changed, and `recall` leads with a warning rather than quoting a passage
+that has since been edited:
+
+```
+NOTE: the corpus is out of date. 1 indexed source has changed since it was
+built: flow-docs/04-shipping.md. The passages below may be superseded — run
+`docspack index` again before relying on them.
+```
+
+`recall` is deliberately not `ask`: your notes are never an installed version, so
+a corpus cannot reach an answer about a dependency and a dependency cannot reach
+an answer about your notes. The index lands in `.docspack/local.db` as plaintext
+and the tool writes a `.gitignore` beside it.
+
+The two routes do not merge. `bpmnkit-docs` searches your corpus and the
+installed packs together because a pack directory is just a directory; upstream
+keeps them in separate query paths on purpose. Build a pack when you want one
+answer drawn from both; use `docspack index` when the corpus is a database, or
+when you want the staleness check.
+
+> **Use `docspack@1.2.0` or newer for the Camunda pack.** Earlier versions named
+> one pack per npm scope, so `docspack sync` read `@bpmnkit/camunda-docspack` as
+> an ordinary dependency and indexed its type declarations — `0 chunks
+> (declarations)` — leaving a Camunda question to be answered out of the wrong
+> pack. 1.2.0 discovers `@<vendor>/<name>-docspack` and indexes all 1,054 chunks.
+> `bpmnkit-docs` has read the suffix from the start and needs no version floor.
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli.md

@@ -0,0 +1,86 @@
+# Using BPMN Kit with AI — From the library instead of the CLI
+
+A long-lived agent, an editor extension or an MCP server should index once and
+ask many times, rather than paying for the index on every question:
+
+```typescript
+import { answer, discoverPacks, indexPacks } from "@bpmnkit/docspack";
+
+const index = indexPacks(discoverPacks());
+
+const { hits, tokens } = answer(index, "verify a worker's job type", {
+  packs: ["@bpmnkit/docspack"],
+  limit: 3,
+  maxTokens: 3000,
+});
+
+for (const hit of hits) console.log(hit.chunkId, hit.content);
+console.log(`${tokens} tokens`);
+```
+
+
+## Indexing your own corpus
+
+The packs above answer for BPMN Kit and for Camunda. Nothing answers for *your*
+process — the five Markdown files somebody wrote describing how orders are
+fulfilled. Handed the folder, an agent reads the wrong file or spends its whole
+context on all of them; a corpus larger than the context window cannot be read
+into it at all.
+
+Index it, and it becomes something the agent asks questions of. The same builder
+behind `bpmnkit-docs build` takes any folder of Markdown:
+
+```sh
+mkdir -p flow-corpus
+cat > flow-corpus/package.json <<'JSON'
+{
+  "name": "order-fulfilment-corpus",
+  "version": "1.0.0",
+  "private": true,
+  "docspack": { "source": "../flow-docs", "minTokens": 60, "maxTokens": 800 }
+}
+JSON
+
+npx bpmnkit-docs build --cwd flow-corpus
+npx bpmnkit-docs ask "when does an order need manager approval" --cwd flow-corpus
+```
+
+```
+Built 5 chunks from 5 documents (421 tokens).
+
+## order-fulfilment-corpus@1.0.0/02-approval.when-approval-is-needed
+
+# Approval — When approval is needed
+
+An order over 10000 EUR needs a regional manager to approve it before anything
+is picked. At or under that figure the order goes straight to fulfilment.
+```
+
+Indexing runs no model, so building the corpus costs no tokens — five documents
+take about 9ms.
+
+A few things decide whether the result is any good:
+
+- **Split at headings that answer something.** A chunk is a `##` section.
+  `minTokens` merges a section too short to answer anything into the one before
+  it, so a two-line heading does not become a chunk of its own.
+- **`--cwd` points at the pack, not at the sources.** A directory holding a
+  `package.json` and a `.llms/` payload *is* a pack, so `bpmnkit-docs` reads it
+  without it ever being published.
+- **Your corpus and the installed packs are searched together.** Discovery walks
+  `node_modules` up from `--cwd`, so a corpus inside your project sees
+  `@bpmnkit/docspack` too, and `--pack` narrows to whichever you want.
+- **Keep it out of git, and re-index after editing.** The chunks are a copy of
+  your files. Edit a source and the index is stale until you build again —
+  `bpmnkit-docs build` is cheap enough to run on every change.
+- **Tags weigh 3× prose.** Front matter, the slug and the heading's own words
+  become tags automatically; steer them from the document itself when the words
+  a reader would search for are not the words on the page:
+
+  ```md
+  ## Escalation
+
+  ```
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.md

@@ -0,0 +1,17 @@
+# Using BPMN Kit with AI
+
+An agent asked to turn a folder of specs into a deployable process needs three
+different kinds of knowledge, and only one of them is in its weights:
+
+| It needs to know | Where that lives | How it asks |
+| --- | --- | --- |
+| How to drive this library | `@bpmnkit/docspack` | `bpmnkit-docs ask "…"` |
+| How the engine behaves | `@bpmnkit/camunda-docspack` | `bpmnkit-docs ask "…" --pack @bpmnkit/camunda-docspack` |
+| What the process actually does | your own Markdown | index it yourself, below |
+
+All three are offline retrieval. Nothing here calls a model, starts a server or
+touches the network, so a question costs milliseconds and no tokens. The model
+is only spent on the last step — turning what it found into a diagram.
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.runnable-examples.md

@@ -0,0 +1,31 @@
+# Using BPMN Kit with AI — Runnable examples
+
+Three scripts in [`apps/examples/src/ai`](https://github.com/bpmnkit/monorepo/tree/main/apps/examples/src/ai)
+do exactly the above. They need no API key and no network — the whole set runs
+in about three seconds:
+
+```sh
+pnpm --filter @bpmnkit/examples ai:ask     # ask both packs, from the library
+pnpm --filter @bpmnkit/examples ai:index   # 5 Markdown files → an askable corpus
+pnpm --filter @bpmnkit/examples ai:bpmn    # corpus → CompactDiagram → .bpmn
+```
+
+`ai:bpmn` writes `output/order-fulfilment.bpmn`: 18 elements, 20 sequence flows,
+laid out, with the gateway defaults set.
+
+
+## Keeping it fast
+
+| What | Cost | Why |
+| --- | --- | --- |
+| `ask` scoped with `--pack @bpmnkit/docspack` | ~150ms | indexes one pack |
+| `ask` across both packs | ~650ms | indexes both, 1,200+ chunks |
+| `indexPacks` once, then `answer` per question | ~0ms per question | the index is the expensive part |
+| Building a 5-document corpus | ~9ms | no model, no network |
+
+Reading chunks off disk dominates, and a fresh `npx bpmnkit-docs ask` pays it on
+every question. Scope with `--pack` when you know which pack answers; use the
+library and hold the index when you are asking more than a handful of questions.
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.telling-an-agent-they-exist.md

@@ -0,0 +1,23 @@
+# Using BPMN Kit with AI — Telling an agent they exist
+
+An agent that does not know a pack is installed will answer from memory instead,
+and its memory describes an older release. One paragraph in `AGENTS.md`,
+`CLAUDE.md` or `.cursor/rules` is the whole setup — **name both packs**, because
+an agent told only about the first will never think to ask the second:
+
+```md
+Documentation is installed locally. Ask it before answering from memory.
+
+- BPMN Kit's own APIs, CLI and guides:
+  `npx bpmnkit-docs ask "<question>"`
+- Camunda 8 — BPMN semantics, FEEL, engine behaviour, the REST API:
+  `npx bpmnkit-docs ask "<question>" --pack @bpmnkit/camunda-docspack`
+
+A returned chunk beats recalled knowledge: it describes the version this project
+installed. If the two disagree, the chunk is right — do not blend them.
+Answers cap at 3 chunks / 3,000 tokens, so ask several narrow questions rather
+than one broad one.
+```
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.the-two-packs-bpmn-kit-ships.md

@@ -0,0 +1,20 @@
+# Using BPMN Kit with AI — The two packs BPMN Kit ships
+
+```sh
+npm i -D @bpmnkit/docspack @bpmnkit/camunda-docspack
+```
+
+**[`@bpmnkit/docspack`](/docs/packages/docspack)** carries the documentation you
+are reading — the builder API, the CLI, the guides — pinned to the version this
+project installed.
+
+**[`@bpmnkit/camunda-docspack`](/docs/packages/camunda-docspack)** carries the
+Camunda 8 documentation: BPMN and FEEL references, engine concepts, the
+best-practice pages with their diagrams rendered as text, and one digest per
+Orchestration Cluster API operation. It is Camunda's work, redistributed under
+CC BY-SA 3.0, not documentation BPMN Kit wrote.
+
+One `bpmnkit-docs` command reads both.
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.the-whole-loop-five-markdown-files-to-a-bpmn-diagram.md

@@ -0,0 +1,64 @@
+# Using BPMN Kit with AI — The whole loop: five Markdown files to a BPMN diagram
+
+Put the three together and the agent's job is narrow enough to be reliable:
+
+1. **Index the team's prose** and ask it what the flow actually does — where the
+   thresholds are, what runs in parallel, what happens on the unhappy path.
+2. **Ask `@bpmnkit/docspack`** how to express that with this library.
+3. **Ask `@bpmnkit/camunda-docspack`** whatever the engine, not the library,
+   decides — gateway semantics, FEEL syntax, job types.
+4. **Return a `CompactDiagram`**, not XML. About 40 lines of JSON for a diagram
+   that is 200 lines of BPMN, and a model that has never written valid BPMN XML
+   can still produce a valid diagram.
+5. **`expand` it**, which is deterministic — layout included.
+
+```typescript
+import { Bpmn, expand } from "@bpmnkit/core";
+import type { CompactDiagram } from "@bpmnkit/core";
+import { answer, buildPack, indexPacks, loadPack } from "@bpmnkit/docspack";
+
+// 1. The team's own files, indexed.
+buildPack({
+  source: "flow-docs",
+  packDir: "flow-corpus",
+  name: "order-fulfilment-corpus",
+  version: "1.0.0",
+  documents: ["order-fulfilment-corpus"],
+  minTokens: 60,
+});
+const corpus = indexPacks([loadPack("flow-corpus")]);
+
+const facts = ["when does an order need manager approval", "what runs in parallel"]
+  .flatMap((q) => answer(corpus, q, { limit: 1, maxTokens: 600 }).hits)
+  .map((hit) => hit.content);
+
+// 2–4. The model reads `facts` and returns this. Nothing here is XML.
+const compact: CompactDiagram = await writeDiagram(facts);
+
+// 5. Deterministic from here on: topology, Zeebe bindings and layout.
+const definitions = expand(compact);
+const xml = Bpmn.export(definitions);
+```
+
+**Mark every gateway's fallthrough branch.** An exclusive gateway whose
+conditions are all false and which has no default deadlocks at runtime, so the
+branch without a condition carries `isDefault` instead:
+
+```typescript
+flows: [
+  { id: "f5", from: "needsApproval", to: "approveOrder", condition: "= total > 10000" },
+  { id: "f6", from: "needsApproval", to: "splitWork", name: "at or under", isDefault: true },
+]
+```
+
+`expand` turns it into the gateway's `bpmn:default` attribute, `compactify` reads
+it back, and `reconcileCompact` sets it on a file somebody else authored. A flow
+marked `isDefault` that does not leave an exclusive, inclusive or complex
+gateway, or a gateway with two of them, throws rather than being dropped.
+
+> `CompactDiagram` still does not model everything. See
+> [AI Integration](/docs/guides/ai) for what it drops, and use `reconcileCompact`
+> rather than `expand` when you are editing a file you need to keep.
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/guides.using-bpmnkit-with-ai.where-to-go-next.md

@@ -0,0 +1,13 @@
+# Using BPMN Kit with AI — Where to go next
+
+- [AI Integration](/docs/guides/ai) — the compact format, prompting, the Claude
+  and OpenAI calls, and the MCP server
+- [Building Processes with AI](/docs/guides/ai-implement) — the `ProcessPlan`
+  pipeline, which compiles rather than generating XML
+- [AI Agents](/docs/guides/ai-agents) — putting an LLM *inside* a process as a
+  Camunda AI Agent Sub-process
+- [Claude Code Plugin](/docs/guides/claude-code-plugin) — the slash commands that
+  drive all of it
+
+---
+Source: https://bpmnkit.com/docs/guides/using-bpmnkit-with-ai

package/.llms/chunks/packages.camunda-docspack.a-note-on-the-pack-s-name.md

@@ -0,0 +1,15 @@
+# @bpmnkit/camunda-docspack — A note on the pack's name
+
+A vendor that redistributes somebody else's documentation needs a second pack, so
+this one is `@bpmnkit/camunda-docspack` rather than a second `@bpmnkit/docspack`.
+The name is still a pure check inside a scope BPMN Kit owns, so the pack carries
+the same trust as `@bpmnkit/docspack`.
+
+The docspack spec originally named one pack per npm scope, and `bpmnkit-docs`
+read the `-docspack` suffix ahead of it. Upstream adopted the shape in
+**`docspack@1.2.0`**, so both readers now find this pack — but a `docspack` CLI
+older than 1.2.0 will not, and will answer Camunda questions out of
+`@bpmnkit/docspack` instead. `bpmnkit-docs` has no such floor.
+
+---
+Source: https://bpmnkit.com/docs/packages/camunda-docspack

package/.llms/chunks/packages.camunda-docspack.installation.md

@@ -0,0 +1,41 @@
+# @bpmnkit/camunda-docspack — Installation
+
+```sh
+pnpm add -D @bpmnkit/camunda-docspack
+```
+
+There is no second CLI to learn: `bpmnkit-docs`, from
+[`@bpmnkit/docspack`](/docs/packages/docspack), reads every pack installed.
+
+
+## Asking it
+
+```sh
+npx bpmnkit-docs ask "how should I name an exclusive gateway" \
+  --pack @bpmnkit/camunda-docspack
+npx bpmnkit-docs ask "POST /jobs/activation" --pack @bpmnkit/camunda-docspack
+npx bpmnkit-docs ask "what permissions does creating a process instance need" \
+  --pack @bpmnkit/camunda-docspack
+```
+
+`--pack` both disambiguates and pays for itself: the index is built by reading
+every chunk off disk, so narrowing to one pack is roughly 150ms against 650ms
+across both. Leave it off when you do not know which pack answers.
+
+Confirm it is installed before relying on it:
+
+```sh
+npx bpmnkit-docs list
+```
+
+```
+@bpmnkit/camunda-docspack@0.1.1  1054 chunks
+@bpmnkit/docspack@0.0.5  206 chunks
+```
+
+A pack missing from that list is a pack no answer can come from. See
+[Using BPMN Kit with AI](/docs/guides/using-bpmnkit-with-ai) for the paragraph to
+put in `AGENTS.md` or `CLAUDE.md` so an agent knows to ask both.
+
+---
+Source: https://bpmnkit.com/docs/packages/camunda-docspack

package/.llms/chunks/packages.camunda-docspack.overview.md

@@ -0,0 +1,28 @@
+# @bpmnkit/camunda-docspack — Overview
+
+`@bpmnkit/camunda-docspack` packages the **Camunda 8 documentation** as a
+[docspack](https://docspack.dev/spec) pack you can search offline: BPMN and FEEL
+references, engine concepts, the best-practice pages, and one digest per
+Orchestration Cluster API operation.
+
+It is the companion to [`@bpmnkit/docspack`](/docs/packages/docspack), and the
+split is the point. Ask ours how to *drive the library*; ask this one what the
+*engine* does — gateway semantics, FEEL syntax, job activation, permissions.
+Those are different questions and the right answer to one is the wrong answer to
+the other.
+
+> **This is Camunda's documentation, not BPMN Kit's.** The content is the work of
+> Camunda Services GmbH and copyright in it remains with them. This package adds
+> only the tooling that stages, chunks and indexes it. It is redistributed under
+> **CC BY-SA 3.0**, the licence Camunda publishes it under — which is why this
+> package is CC BY-SA 3.0 rather than MIT like the rest of BPMN Kit. BPMN Kit is
+> not affiliated with, endorsed by or sponsored by Camunda. For canonical and
+> current documentation prefer [docs.camunda.io](https://docs.camunda.io).
+
+It is built from the `docs/` tree of
+[camunda/camunda-docs](https://github.com/camunda/camunda-docs) — the unreleased
+**8.10** documentation — plus the Orchestration Cluster API specification, and
+rebuilt weekly.
+
+---
+Source: https://bpmnkit.com/docs/packages/camunda-docspack

package/.llms/chunks/packages.camunda-docspack.rebuilding-it.md

@@ -0,0 +1,27 @@
+# @bpmnkit/camunda-docspack — Rebuilding it
+
+A weekly workflow (`.github/workflows/camunda-docspack.yml`) rebuilds the pack
+from upstream. By hand you need a camunda-docs checkout:
+
+```sh
+node packages/camunda-docspack/dist/cli.js --camunda-docs ../camunda-docs
+```
+
+
+## API Reference
+
+The published artefact is the `.llms/` payload; these exports are the build that
+produces it.
+
+| Export | Purpose |
+| --- | --- |
+| `build(options)` | Stage a camunda-docs checkout and write the `.llms/` payload |
+| `stage(options)` | Run the staging transforms only, to a directory |
+| `bpmnToText(xml)` | Render a BPMN diagram as a compact flow description |
+| `readOperations(entry)` | Read one digest per operation from an OpenAPI document |
+| `stripMdx(source, options)` | Reduce Camunda's MDX to indexable Markdown |
+| `absoluteLinks(markdown, slug)` | Rewrite relative links to `docs.camunda.io` URLs |
+| `notice(commit)` | The CC BY-SA 3.0 attribution written on every build |
+
+---
+Source: https://bpmnkit.com/docs/packages/camunda-docspack

package/.llms/chunks/packages.camunda-docspack.what-makes-this-corpus-different.md

@@ -0,0 +1,16 @@
+# @bpmnkit/camunda-docspack — What makes this corpus different
+
+- **Diagrams as text.** The best-practice pages argue through embedded BPMN
+  diagrams, and Camunda's own Markdown export drops them. Each one is rendered as
+  a flow description instead, so a page about naming gateways still contains the
+  gateway, its question and its conditions.
+- **227 API operations.** One digest per endpoint, read from the specification
+  rather than from the generated reference pages, with required permissions
+  decoded, the version it appeared in, and its consistency guarantee.
+- **Every chunk cites its page.** Links are rewritten to absolute
+  `docs.camunda.io` URLs and each chunk ends with the page it came from.
+- **Nothing dropped silently.** An MDX component the build does not recognise
+  fails the build by file and line rather than quietly thinning the corpus.
+
+---
+Source: https://bpmnkit.com/docs/packages/camunda-docspack

package/.llms/chunks/packages.core.installation-compactify-definitions.md

@@ -6,6 +6,14 @@ Zeebe bindings, and drops collaborations, participants, message flows, lanes, da
 artifacts, root-level messages and errors, multi-instance loop characteristics, full
 `zeebe:ioMapping` entries and diagram interchange.
 
+A sequence flow leaving an exclusive, inclusive or complex gateway carries `isDefault: true`
+when the gateway names it in `bpmn:default`. It sits on the flow rather than on the gateway
+because that is where its alternative, `condition`, sits — a model writing the branches of a
+decision marks one of them instead of pointing back at a flow id. `expand` turns it into the
+attribute; a flow marked `isDefault` that leaves anything else, or a gateway with two of them,
+throws rather than being dropped, because a lost default is a gateway that deadlocks the first
+time every condition is false.
+
 `documentation` is carried on every element and on the process itself, because in Camunda 8 it
 is not decoration: on an ad-hoc sub-process child it is the tool description handed to the LLM,
 and on a start event it is where the process input contract is written. It had been dropped, so

package/.llms/chunks/{packages.docspack.installation.md → packages.docspack.giving-an-agent-access.md}

@@ -1,18 +1,13 @@
-# @bpmnkit/docspack — Installation
-
-```sh
-pnpm add -D @bpmnkit/docspack
-```
-
-
-## Giving an agent access
+# @bpmnkit/docspack — Giving an agent access
 
 Any agent with a shell can run the command, so one paragraph in `AGENTS.md`, `CLAUDE.md`
 or `.cursor/rules` is the whole setup:
 
 ```md
-Run `npx bpmnkit-docs ask "<question>"` for BPMN Kit documentation. It answers
-from the version this project installed. Prefer what it returns over recalled
+Run `npx bpmnkit-docs ask "<question>"` for BPMN Kit documentation, and
+`npx bpmnkit-docs ask "<question>" --pack @bpmnkit/camunda-docspack` for Camunda 8
+documentation — BPMN semantics, FEEL, engine behaviour, the REST API. Both answer
+from the versions this project installed. Prefer what they return over recalled
 knowledge — when the two disagree, the retrieved chunk is right.
 ```
 

package/.llms/chunks/packages.docspack.reading-it-yourself.md

@@ -30,5 +30,11 @@ with the versions installed.
 
 Options: `--limit <n>`, `--max-tokens <n>`, `--pack <name>`, `--cwd <dir>`.
 
+`--pack` narrows before the index is built, not after, so asking one pack a
+question does not pay for reading the others — roughly 150ms against 650ms
+across both packs. A name that is not installed is an error listing what is,
+rather than an empty answer that would read as "the documentation does not cover
+this".
+
 ---
 Source: https://bpmnkit.com/docs/packages/docspack

package/.llms/chunks/packages.docspack.the-other-pack.md

@@ -0,0 +1,24 @@
+# @bpmnkit/docspack — The other pack
+
+BPMN Kit publishes a second pack:
+**[`@bpmnkit/camunda-docspack`](/docs/packages/camunda-docspack)**, the Camunda 8
+documentation — BPMN and FEEL references, engine concepts, best practices and the
+Orchestration Cluster API. `bpmnkit-docs` reads both, so ask this package how to
+drive the library and that one what the engine does:
+
+```sh
+npx bpmnkit-docs ask "how should I name an exclusive gateway" --pack @bpmnkit/camunda-docspack
+```
+
+Install them together, and tell your agent about both — see
+[Using BPMN Kit with AI](/docs/guides/using-bpmnkit-with-ai).
+
+
+## Installation
+
+```sh
+pnpm add -D @bpmnkit/docspack @bpmnkit/camunda-docspack
+```
+
+---
+Source: https://bpmnkit.com/docs/packages/docspack

package/.llms/manifest.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://docspack.dev/schema/v1.json",
 	"name": "@bpmnkit/docspack",
-	"version": "0.0.4",
+	"version": "0.0.6",
 	"documents": [
 		"@bpmnkit/core",
 		"@bpmnkit/canvas",
@@ -925,7 +925,7 @@
 		{
 			"id": "guides.ai.minimal-empty-diagram",
 			"file": "chunks/guides.ai.minimal-empty-diagram.md",
-			"tokens": 229,
+			"tokens": 247,
 			"tags": [
 				"guides",
 				"ai",
@@ -1454,6 +1454,159 @@
 				"engine.getDeployedProcesses()"
 			]
 		},
+		{
+			"id": "guides.using-bpmnkit-with-ai",
+			"file": "chunks/guides.using-bpmnkit-with-ai.md",
+			"tokens": 210,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai"
+			],
+			"entities": [
+				"@bpmnkit/docspack",
+				"@bpmnkit/camunda-docspack"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.the-two-packs-bpmn-kit-ships",
+			"file": "chunks/guides.using-bpmnkit-with-ai.the-two-packs-bpmn-kit-ships.md",
+			"tokens": 147,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"two",
+				"packs",
+				"bpmn",
+				"kit",
+				"ships"
+			],
+			"entities": [
+				"@bpmnkit/docspack",
+				"@bpmnkit/camunda-docspack"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.telling-an-agent-they-exist",
+			"file": "chunks/guides.using-bpmnkit-with-ai.telling-an-agent-they-exist.md",
+			"tokens": 224,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"telling",
+				"agent",
+				"they",
+				"exist"
+			],
+			"entities": [
+				"AGENTS.md",
+				"CLAUDE.md"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.asking",
+			"file": "chunks/guides.using-bpmnkit-with-ai.asking.md",
+			"tokens": 314,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"asking"
+			],
+			"entities": [
+				"BpmnDefinitions",
+				"CompactDiagram"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli",
+			"file": "chunks/guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli.md",
+			"tokens": 706,
+			"tags": [
+				"carrier",
+				"refused",
+				"dispatcher",
+				"guides",
+				"using-bpmnkit-with-ai",
+				"library",
+				"instead",
+				"cli"
+			],
+			"entities": [
+				"minTokens",
+				"package.json",
+				"@bpmnkit/docspack"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli-the-other-route-docspack-index",
+			"file": "chunks/guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli-the-other-route-docspack-index.md",
+			"tokens": 551,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"library",
+				"instead",
+				"cli",
+				"other",
+				"route",
+				"docspack",
+				"index"
+			],
+			"entities": [
+				"@bpmnkit/camunda-docspack"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.the-whole-loop-five-markdown-files-to-a-bpmn-diagram",
+			"file": "chunks/guides.using-bpmnkit-with-ai.the-whole-loop-five-markdown-files-to-a-bpmn-diagram.md",
+			"tokens": 604,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"whole",
+				"loop",
+				"five",
+				"markdown",
+				"files",
+				"bpmn",
+				"diagram"
+			],
+			"entities": [
+				"@bpmnkit/docspack",
+				"@bpmnkit/camunda-docspack",
+				"CompactDiagram",
+				"isDefault",
+				"reconcileCompact"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.runnable-examples",
+			"file": "chunks/guides.using-bpmnkit-with-ai.runnable-examples.md",
+			"tokens": 312,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"runnable",
+				"examples"
+			],
+			"entities": [
+				"apps/examples/src/ai",
+				"output/order-fulfilment.bpmn",
+				"indexPacks"
+			]
+		},
+		{
+			"id": "guides.using-bpmnkit-with-ai.where-to-go-next",
+			"file": "chunks/guides.using-bpmnkit-with-ai.where-to-go-next.md",
+			"tokens": 117,
+			"tags": [
+				"guides",
+				"using-bpmnkit-with-ai",
+				"next"
+			],
+			"entities": [
+				"ProcessPlan"
+			]
+		},
 		{
 			"id": "guides.vscode",
 			"file": "chunks/guides.vscode.md",
@@ -1788,6 +1941,80 @@
 			],
 			"entities": []
 		},
+		{
+			"id": "packages.camunda-docspack.overview",
+			"file": "chunks/packages.camunda-docspack.overview.md",
+			"tokens": 308,
+			"tags": [
+				"packages",
+				"camunda-docspack",
+				"overview"
+			],
+			"entities": [
+				"@bpmnkit/camunda-docspack",
+				"@bpmnkit/docspack",
+				"docs/"
+			]
+		},
+		{
+			"id": "packages.camunda-docspack.installation",
+			"file": "chunks/packages.camunda-docspack.installation.md",
+			"tokens": 252,
+			"tags": [
+				"packages",
+				"camunda-docspack",
+				"installation"
+			],
+			"entities": [
+				"@bpmnkit/docspack",
+				"AGENTS.md",
+				"CLAUDE.md"
+			]
+		},
+		{
+			"id": "packages.camunda-docspack.what-makes-this-corpus-different",
+			"file": "chunks/packages.camunda-docspack.what-makes-this-corpus-different.md",
+			"tokens": 192,
+			"tags": [
+				"packages",
+				"camunda-docspack",
+				"makes",
+				"corpus",
+				"different"
+			],
+			"entities": [
+				"docs.camunda.io"
+			]
+		},
+		{
+			"id": "packages.camunda-docspack.rebuilding-it",
+			"file": "chunks/packages.camunda-docspack.rebuilding-it.md",
+			"tokens": 227,
+			"tags": [
+				"packages",
+				"camunda-docspack",
+				"rebuilding"
+			],
+			"entities": [
+				"docs.camunda.io"
+			]
+		},
+		{
+			"id": "packages.camunda-docspack.a-note-on-the-pack-s-name",
+			"file": "chunks/packages.camunda-docspack.a-note-on-the-pack-s-name.md",
+			"tokens": 165,
+			"tags": [
+				"packages",
+				"camunda-docspack",
+				"note",
+				"pack",
+				"name"
+			],
+			"entities": [
+				"@bpmnkit/camunda-docspack",
+				"@bpmnkit/docspack"
+			]
+		},
 		{
 			"id": "packages.canvas.overview",
 			"file": "chunks/packages.canvas.overview.md",
@@ -2214,7 +2441,7 @@
 		{
 			"id": "packages.core.installation-compactify-definitions",
 			"file": "chunks/packages.core.installation-compactify-definitions.md",
-			"tokens": 204,
+			"tokens": 342,
 			"tags": [
 				"packages",
 				"core",
@@ -2224,7 +2451,8 @@
 			],
 			"entities": [
 				"BpmnDefinitions",
-				"CompactDiagram"
+				"CompactDiagram",
+				"isDefault"
 			]
 		},
 		{
@@ -2463,13 +2691,29 @@
 			]
 		},
 		{
-			"id": "packages.docspack.installation",
-			"file": "chunks/packages.docspack.installation.md",
-			"tokens": 251,
+			"id": "packages.docspack.the-other-pack",
+			"file": "chunks/packages.docspack.the-other-pack.md",
+			"tokens": 145,
 			"tags": [
 				"packages",
 				"docspack",
-				"installation"
+				"other",
+				"pack"
+			],
+			"entities": [
+				"@bpmnkit/camunda-docspack"
+			]
+		},
+		{
+			"id": "packages.docspack.giving-an-agent-access",
+			"file": "chunks/packages.docspack.giving-an-agent-access.md",
+			"tokens": 268,
+			"tags": [
+				"packages",
+				"docspack",
+				"giving",
+				"agent",
+				"access"
 			],
 			"entities": [
 				"AGENTS.md",
@@ -2479,7 +2723,7 @@
 		{
 			"id": "packages.docspack.reading-it-yourself",
 			"file": "chunks/packages.docspack.reading-it-yourself.md",
-			"tokens": 252,
+			"tokens": 329,
 			"tags": [
 				"packages",
 				"docspack",

package/README.md

@@ -22,6 +22,8 @@ An agent installs it, asks a question, and gets back the two or three passages t
 
 It follows the [docspack package format](https://docspack.dev/spec), so the upstream `docspack` CLI discovers and indexes it like any other vendor pack. The bundled `bpmnkit-docs` command does the same job with no extra tooling.
 
+It also reads [`@bpmnkit/camunda-docspack`](https://www.npmjs.com/package/@bpmnkit/camunda-docspack) — the Camunda 8 documentation in the same format. Install both and ask this one how to drive the library, that one what the engine does.
+
 ```
 Markdown docs → chunks + manifest → BM25 index → three passages
 ```
@@ -44,17 +46,20 @@ npm install -D @bpmnkit/docspack
 
 ## Quick Start
 
-Give an agent one line in `AGENTS.md` or `CLAUDE.md`:
+Give an agent one paragraph in `AGENTS.md` or `CLAUDE.md` — naming both packs, because an agent told only about the first will never think to ask the second:
 
 ```
-Run \`npx bpmnkit-docs ask "<question>"\` for BPMN Kit documentation.
-It answers from the version this project installed.
+Run `npx bpmnkit-docs ask "<question>"` for BPMN Kit documentation, and
+`npx bpmnkit-docs ask "<question>" --pack @bpmnkit/camunda-docspack` for
+Camunda 8 documentation — BPMN semantics, FEEL, engine behaviour, the REST API.
+Both answer from the versions this project installed.
 ```
 
 Then:
 
 ```sh
 npx bpmnkit-docs ask "how do I deploy a process to Camunda 8"
+npx bpmnkit-docs ask "what happens when no gateway condition is true" --pack @bpmnkit/camunda-docspack
 npx bpmnkit-docs search "exclusive gateway"
 npx bpmnkit-docs list
 ```
@@ -111,6 +116,8 @@ function loadPack(dir: string): Pack
 
 Options: `--limit <n>`, `--max-tokens <n>`, `--pack <name>`, `--cwd <dir>`.
 
+`--pack` narrows before the index is built, not after, so asking one pack a question does not pay for reading the others. A name that is not installed is an error listing what is, rather than an empty answer that would read as "the documentation does not cover this".
+
 ---
 
 ## Related Packages
@@ -125,6 +132,7 @@ Options: `--limit <n>`, `--max-tokens <n>`, `--pack <name>`, `--cwd <dir>`.
 | [`@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/camunda-docspack`](https://www.npmjs.com/package/@bpmnkit/camunda-docspack) | Camunda 8 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 |

package/dist/chunk.js

@@ -25,7 +25,7 @@ export function chunkDocument(doc, options = {}) {
             if (text === "")
                 continue;
             const directives = readDirectives(part.lines);
-            const chunkTitle = part.heading === "" ? title : `${title} — ${part.heading}`;
+            const chunkTitle = joinHeadings(title, part.heading);
             const source = options.siteUrl ? `\n\n---\nSource: ${options.siteUrl}/${doc.slug}` : "";
             const bodyText = `# ${chunkTitle}\n\n${stripDirectives(text)}${source}\n`;
             chunks.push({
@@ -116,8 +116,7 @@ function subdivide(section, maxTokens) {
         return [section];
     const parts = [];
     for (const sub of splitByHeading(section.lines.join("\n"), 3)) {
-        const heading = sub.heading === "" ? section.heading : `${section.heading} — ${sub.heading}`;
-        parts.push(...byParagraph({ heading, lines: sub.lines }, maxTokens));
+        parts.push(...byParagraph({ heading: joinHeadings(section.heading, sub.heading), lines: sub.lines }, maxTokens));
     }
     return parts.length > 0 ? parts : [section];
 }
@@ -132,7 +131,7 @@ function byParagraph(section, maxTokens) {
         if (current.join("").trim() === "")
             return;
         const suffix = parts.length === 0 ? "" : ` (${parts.length + 1})`;
-        parts.push({ heading: `${section.heading}${suffix}`, lines: current });
+        parts.push({ heading: `${section.heading}${suffix}`.trim(), lines: current });
         current = [];
     };
     for (const line of section.lines) {
@@ -177,6 +176,17 @@ function stripDirectives(text) {
         .join("\n")
         .trim();
 }
+/**
+ * Join a chunk's heading trail, dropping the levels that have no heading of their own.
+ *
+ * A document whose text before the first `##` is shorter than `minTokens` is merged into the
+ * section after it, and the merged section keeps the preamble's empty heading. Composing that
+ * blindly produced a hole in the middle of the trail — `Naming BPMN elements —  — Naming
+ * gateways` — which is what a reader sees at the top of the chunk and what an answer cites.
+ */
+function joinHeadings(...parts) {
+    return parts.filter((part) => part.trim() !== "").join(" — ");
+}
 /** Heading words carry the topic; function words carry nothing worth weighting 3x. */
 function headingTags(heading) {
     return tokenize(heading).filter((word) => word.length > 2 && !STOP_WORDS.has(word));

package/dist/cli.js

@@ -72,8 +72,18 @@ function main(argv) {
         return 1;
     }
     const selected = args.options.get("pack");
+    // Narrowing before indexing, not after: every chunk of every pack is read from
+    // disk to build the index, so asking one pack a question should not pay for
+    // the others. It is the difference between ~60ms and ~650ms here.
+    const scoped = selected === undefined ? packs : packs.filter((pack) => pack.name === selected);
+    if (scoped.length === 0) {
+        process.stderr.write(`No documentation package named "${selected}". Found: ${packs
+            .map((pack) => pack.name)
+            .join(", ")}\n`);
+        return 1;
+    }
     const scope = selected ? { packs: [selected] } : {};
-    const index = indexPacks(packs);
+    const index = indexPacks(scoped);
     if (args.command === "search") {
         const hits = search(index, query, { ...scope, limit: number(args, "limit", 10) });
         process.stdout.write(formatSearch(query, hits));

package/dist/load.d.ts

@@ -18,8 +18,16 @@ export declare function chunkPath(packDir: string, chunk: ManifestChunk): string
 export declare function readChunk(pack: Pack, chunk: ManifestChunk): string;
 /**
  * Every documentation package reachable from `cwd`: the vendor-scoped
- * `@<vendor>/docspack` and community `@docspack-community/*` packages installed
- * in any `node_modules` up the tree, plus `cwd` itself when it is a pack.
+ * `@<vendor>/docspack`, its `@<vendor>/<name>-docspack` siblings, and community
+ * `@docspack-community/*` packages installed in any `node_modules` up the tree,
+ * plus `cwd` itself when it is a pack.
+ *
+ * The suffix is for a vendor that also redistributes somebody else's
+ * documentation — `@bpmnkit/camunda-docspack` is ours — and had nowhere to put
+ * it when the spec named one pack per scope. It is still a pure name check,
+ * inside a scope that vendor owns, so the pack carries the same trust as the
+ * bare name and nothing here has to reach the network to decide. Upstream
+ * adopted the same shape in `docspack@1.2.0`.
  */
 export declare function discoverPacks(cwd?: string): Pack[];
 /** Load every chunk of every pack into a searchable index. */

package/dist/load.js

@@ -65,8 +65,16 @@ export function readChunk(pack, chunk) {
 }
 /**
  * Every documentation package reachable from `cwd`: the vendor-scoped
- * `@<vendor>/docspack` and community `@docspack-community/*` packages installed
- * in any `node_modules` up the tree, plus `cwd` itself when it is a pack.
+ * `@<vendor>/docspack`, its `@<vendor>/<name>-docspack` siblings, and community
+ * `@docspack-community/*` packages installed in any `node_modules` up the tree,
+ * plus `cwd` itself when it is a pack.
+ *
+ * The suffix is for a vendor that also redistributes somebody else's
+ * documentation — `@bpmnkit/camunda-docspack` is ours — and had nowhere to put
+ * it when the spec named one pack per scope. It is still a pure name check,
+ * inside a scope that vendor owns, so the pack carries the same trust as the
+ * bare name and nothing here has to reach the network to decide. Upstream
+ * adopted the same shape in `docspack@1.2.0`.
  */
 export function discoverPacks(cwd = process.cwd()) {
     const found = new Map();
@@ -90,7 +98,11 @@ export function discoverPacks(cwd = process.cwd()) {
                     offer(join(modules, scope, name));
             }
             else {
-                offer(join(modules, scope, "docspack"));
+                for (const name of listDirectory(join(modules, scope))) {
+                    if (name === "docspack" || name.endsWith("-docspack")) {
+                        offer(join(modules, scope, name));
+                    }
+                }
             }
         }
     }

package/dist/search.d.ts

@@ -30,7 +30,11 @@ export declare function buildIndex(inputs: IndexInput[]): DocsIndex;
 export interface SearchOptions {
     /** Maximum hits to return. */
     limit?: number;
-    /** Restrict to these package names — a project asks only about what it installed. */
+    /**
+     * Restrict to these package names — a project asks only about what it
+     * installed. A name that was never indexed throws rather than returning
+     * nothing, so a typo cannot pass for an absence of documentation.
+     */
     packs?: readonly string[];
 }
 /** Rank every chunk that shares a term with the query. Ties break on chunk id. */

package/dist/search.js

@@ -47,10 +47,21 @@ export function buildIndex(inputs) {
 /** Rank every chunk that shares a term with the query. Ties break on chunk id. */
 export function search(index, query, options = {}) {
     const limit = options.limit ?? 3;
+    const allowed = options.packs ? new Set(options.packs) : null;
+    if (allowed) {
+        // Narrowing to a package that was never indexed would otherwise come back
+        // as an empty result, which reads as "the documentation does not cover
+        // this" — a different answer, and the wrong one to hand a model.
+        const indexed = new Set(index.chunks.map((candidate) => candidate.pack.name));
+        for (const name of allowed) {
+            if (!indexed.has(name)) {
+                throw new Error(`No documentation package named "${name}". Indexed: ${[...indexed].sort().join(", ")}`);
+            }
+        }
+    }
     const queryTerms = terms(query);
     if (queryTerms.length === 0)
         return [];
-    const allowed = options.packs ? new Set(options.packs) : null;
     const total = index.chunks.length;
     const hits = [];
     for (const candidate of index.chunks) {

package/llms.txt

@@ -2,7 +2,7 @@
 
 > BPMN Kit documentation as an offline, version-locked docspack package with a built-in search CLI for AI agents
 
-Version 0.0.4. 191 chunks documenting @bpmnkit/core, @bpmnkit/canvas, @bpmnkit/editor, @bpmnkit/engine, @bpmnkit/feel, @bpmnkit/plugins, @bpmnkit/api, @bpmnkit/ascii, @bpmnkit/connector-gen, @bpmnkit/connectors, @bpmnkit/patterns, @bpmnkit/worker-client, @bpmnkit/cli.
+Version 0.0.6. 206 chunks documenting @bpmnkit/core, @bpmnkit/canvas, @bpmnkit/editor, @bpmnkit/engine, @bpmnkit/feel, @bpmnkit/plugins, @bpmnkit/api, @bpmnkit/ascii, @bpmnkit/connector-gen, @bpmnkit/connectors, @bpmnkit/patterns, @bpmnkit/worker-client, @bpmnkit/cli.
 
 ```sh
 npm i -D @bpmnkit/docspack
@@ -83,7 +83,7 @@ npx bpmnkit-docs ask "how do I deploy a process"
 - [Building Processes with AI — Deploying](.llms/chunks/guides.ai-implement.deploying.md) — 255 tokens
 - [Building Processes with AI — Extending an existing process](.llms/chunks/guides.ai-implement.extending-an-existing-process.md) — 100 tokens
 - [AI Integration](.llms/chunks/guides.ai.md) — 478 tokens
-- [AI Integration — Minimal Empty Diagram](.llms/chunks/guides.ai.minimal-empty-diagram.md) — 229 tokens
+- [AI Integration — Minimal Empty Diagram](.llms/chunks/guides.ai.minimal-empty-diagram.md) — 247 tokens
 - [AI Integration — Claude API Example](.llms/chunks/guides.ai.claude-api-example.md) — 226 tokens
 - [AI Integration — OpenAI Function Calling](.llms/chunks/guides.ai.openai-function-calling.md) — 192 tokens
 - [AI Integration — MCP Server](.llms/chunks/guides.ai.mcp-server.md) — 151 tokens
@@ -124,6 +124,15 @@ npx bpmnkit-docs ask "how do I deploy a process"
 - [Simulation — Message Correlation](.llms/chunks/guides.simulation.message-correlation.md) — 144 tokens
 - [Simulation — DMN Decision Evaluation](.llms/chunks/guides.simulation.dmn-decision-evaluation.md) — 251 tokens
 - [Simulation — Multiple Deployments](.llms/chunks/guides.simulation.multiple-deployments.md) — 85 tokens
+- [Using BPMN Kit with AI](.llms/chunks/guides.using-bpmnkit-with-ai.md) — 210 tokens
+- [Using BPMN Kit with AI — The two packs BPMN Kit ships](.llms/chunks/guides.using-bpmnkit-with-ai.the-two-packs-bpmn-kit-ships.md) — 147 tokens
+- [Using BPMN Kit with AI — Telling an agent they exist](.llms/chunks/guides.using-bpmnkit-with-ai.telling-an-agent-they-exist.md) — 224 tokens
+- [Using BPMN Kit with AI — Asking](.llms/chunks/guides.using-bpmnkit-with-ai.asking.md) — 314 tokens
+- [Using BPMN Kit with AI — From the library instead of the CLI](.llms/chunks/guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli.md) — 706 tokens
+- [Using BPMN Kit with AI — From the library instead of the CLI — The other route: `docspack index`](.llms/chunks/guides.using-bpmnkit-with-ai.from-the-library-instead-of-the-cli-the-other-route-docspack-index.md) — 551 tokens
+- [Using BPMN Kit with AI — The whole loop: five Markdown files to a BPMN diagram](.llms/chunks/guides.using-bpmnkit-with-ai.the-whole-loop-five-markdown-files-to-a-bpmn-diagram.md) — 604 tokens
+- [Using BPMN Kit with AI — Runnable examples](.llms/chunks/guides.using-bpmnkit-with-ai.runnable-examples.md) — 312 tokens
+- [Using BPMN Kit with AI — Where to go next](.llms/chunks/guides.using-bpmnkit-with-ai.where-to-go-next.md) — 117 tokens
 - [VS Code Extension](.llms/chunks/guides.vscode.md) — 139 tokens
 - [VS Code Extension — Installing](.llms/chunks/guides.vscode.installing.md) — 140 tokens
 - [VS Code Extension — What it does — Preview beside the source](.llms/chunks/guides.vscode.what-it-does-preview-beside-the-source.md) — 131 tokens
@@ -151,6 +160,11 @@ npx bpmnkit-docs ask "how do I deploy a process"
 - [@bpmnkit/api — Process Operations](.llms/chunks/packages.api.process-operations.md) — 238 tokens
 - [@bpmnkit/api — Incident Resolution](.llms/chunks/packages.api.incident-resolution.md) — 137 tokens
 - [@bpmnkit/api — Observability Events](.llms/chunks/packages.api.observability-events.md) — 94 tokens
+- [@bpmnkit/camunda-docspack — Overview](.llms/chunks/packages.camunda-docspack.overview.md) — 308 tokens
+- [@bpmnkit/camunda-docspack — Installation](.llms/chunks/packages.camunda-docspack.installation.md) — 252 tokens
+- [@bpmnkit/camunda-docspack — What makes this corpus different](.llms/chunks/packages.camunda-docspack.what-makes-this-corpus-different.md) — 192 tokens
+- [@bpmnkit/camunda-docspack — Rebuilding it](.llms/chunks/packages.camunda-docspack.rebuilding-it.md) — 227 tokens
+- [@bpmnkit/camunda-docspack — A note on the pack's name](.llms/chunks/packages.camunda-docspack.a-note-on-the-pack-s-name.md) — 165 tokens
 - [@bpmnkit/canvas — Overview](.llms/chunks/packages.canvas.overview.md) — 161 tokens
 - [@bpmnkit/canvas — Options](.llms/chunks/packages.canvas.options.md) — 147 tokens
 - [@bpmnkit/canvas — Events](.llms/chunks/packages.canvas.events.md) — 269 tokens
@@ -179,7 +193,7 @@ npx bpmnkit-docs ask "how do I deploy a process"
 - [@bpmnkit/core — Installation — `applyBpmnOperations(definitions, operations, options?)`](.llms/chunks/packages.core.installation-applybpmnoperations-definitions-operations-options.md) — 235 tokens
 - [@bpmnkit/core — Installation — `ensureZeebeExtension(owner, extension)`](.llms/chunks/packages.core.installation-ensurezeebeextension-owner-extension.md) — 323 tokens
 - [@bpmnkit/core — Installation — `reconcileCompact(definitions, compact, options?)`](.llms/chunks/packages.core.installation-reconcilecompact-definitions-compact-options.md) — 129 tokens
-- [@bpmnkit/core — Installation — `compactify(definitions)`](.llms/chunks/packages.core.installation-compactify-definitions.md) — 204 tokens
+- [@bpmnkit/core — Installation — `compactify(definitions)`](.llms/chunks/packages.core.installation-compactify-definitions.md) — 342 tokens
 - [@bpmnkit/core — Installation — `expand(compact)`](.llms/chunks/packages.core.installation-expand-compact.md) — 164 tokens
 - [@bpmnkit/core — Installation — `retypeElement(element, type)`](.llms/chunks/packages.core.installation-retypeelement-element-type.md) — 189 tokens
 - [@bpmnkit/core — Installation — `createFlowElement(id, type, options?)`](.llms/chunks/packages.core.installation-createflowelement-id-type-options.md) — 61 tokens
@@ -193,8 +207,9 @@ npx bpmnkit-docs ask "how do I deploy a process"
 - [@bpmnkit/core — Writing files — `@bpmnkit/core/node` — `exportPreserving(original, definitions)`](.llms/chunks/packages.core.writing-files-bpmnkit-core-node-exportpreserving-original-definitions.md) — 598 tokens
 - [@bpmnkit/core — DMN Support](.llms/chunks/packages.core.dmn-support.md) — 113 tokens
 - [@bpmnkit/docspack — Overview](.llms/chunks/packages.docspack.overview.md) — 252 tokens
-- [@bpmnkit/docspack — Installation](.llms/chunks/packages.docspack.installation.md) — 251 tokens
-- [@bpmnkit/docspack — Reading it yourself](.llms/chunks/packages.docspack.reading-it-yourself.md) — 252 tokens
+- [@bpmnkit/docspack — The other pack](.llms/chunks/packages.docspack.the-other-pack.md) — 145 tokens
+- [@bpmnkit/docspack — Giving an agent access](.llms/chunks/packages.docspack.giving-an-agent-access.md) — 268 tokens
+- [@bpmnkit/docspack — Reading it yourself](.llms/chunks/packages.docspack.reading-it-yourself.md) — 329 tokens
 - [@bpmnkit/docspack — Using the index directly](.llms/chunks/packages.docspack.using-the-index-directly.md) — 320 tokens
 - [@bpmnkit/docspack — Trust](.llms/chunks/packages.docspack.trust.md) — 118 tokens
 - [@bpmnkit/editor — Overview](.llms/chunks/packages.editor.overview.md) — 135 tokens

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/docspack",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",