chiltepin 0.47.7 → 0.47.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chiltepin",
-  "version": "0.47.7",
+  "version": "0.47.8",
   "description": "Documentation-as-code CLI: write Markdown with typed YAML blocks for API docs, architecture & system design (C4, ERDs, sequence diagrams), frontend & design systems, ADRs and decision records, planning, and slide presentations. Validate like code with `chiltepin check`, export to HTML, slides, or PDF. AI-native — one-command agent skill (npx skills add jdiejim/chiltepin -y) and a visual Studio.",
   "license": "MIT",
   "type": "module",
@@ -25,9 +25,9 @@
     "picocolors": "^1.1.1",
     "react": "^18.3.1",
     "yaml": "^2.6.1",
-    "chiltepin-render": "0.33.3",
-    "chiltepin-studio": "0.16.3",
-    "chiltepin-core": "0.24.0"
+    "chiltepin-core": "0.25.0",
+    "chiltepin-render": "0.34.0",
+    "chiltepin-studio": "0.16.4"
   },
   "optionalDependencies": {
     "playwright": "^1.49.0"

package/templates/skill/SKILL.md

@@ -93,7 +93,8 @@ content. Rewrite the whole document only when the user requests a rewrite.
 | What causes this? | `fishbone` · `matrix` | one effect, branching causes → fishbone |
 | Why did we decide this? | `options` · `proscons` · `scqa` · `takeaways` · `callout` | the ADR shape → `reference/recipes.md`; the decision alone → callout |
 | What does the API accept and return? | `endpoint` · `code` · `packet` · `table` | HTTP surface → endpoint; wire format → packet; error codes → table |
-| How does the agent behave? | `agentloop` · `trace` · `prompt` · `context` | the loop → agentloop; one real run → trace; the contract → prompt; window contents → context |
+| How does the AI workflow run end to end? | `flow` · `swimlane` · `block` · `cycle` · `sequence` | agents, models, tools, humans and memory as `flow` nodes with `kind: agent / llm / tool / human / memory` — a RAG pipeline, a router, a multi-agent hand-off, a generate-check-repair loop; several owners per step → swimlane; the deployment around it → block; an improve-and-re-evaluate loop → cycle; one turn's timing → sequence. Draw the workflow the request describes; `agentloop` is only the fixed single-agent frame |
+| How does one agent's loop behave? | `agentloop` · `trace` · `prompt` · `context` | the loop → agentloop; one real run → trace; the contract → prompt; window contents → context |
 | What did the review find, and are we ready? | `audit` · `checklist` · `risk` | defects found with evidence → audit; a standard applied once → checklist; what might go wrong → risk |
 | Are we within budget, and how slow is the tail? | `perfbudget` · `percentiles` · `slo` · `benchmark` | targets with a pass line → perfbudget; p50…p99 per endpoint → percentiles; targets over time → slo |
 | Where can this be attacked? | `threatmodel` · `dfd` · `audit` | STRIDE on a data flow with trust boundaries → threatmodel; the flow alone → dfd |

package/templates/skill/reference/blocks/agentic.md

@@ -11,10 +11,12 @@ the window budget (`context`).
 told? What fills the window? What did a real run look like?
 They compose — the AI / agent recipe in `reference/recipes.md` stacks all
 four.
-**Not this family**: the architecture around the agent (services, queues,
-vector stores) → `block` (architecture.md; `kind: llm` / `agent` gets the
-violet card); one turn's message timing between services → `sequence`
-(flows.md).
+**Not this family**: an AI *workflow* — a RAG pipeline, a router, agents
+handing off, a generate → check → repair loop → `flow` (flows.md) with
+`kind: agent / llm / tool / human / memory`; each ask gets its own shape,
+never the fixed agentloop frame. Several owners per step → `swimlane`; the
+deployment around it → `block` (`kind: llm` / `agent`); an improve-and-
+re-evaluate cycle → `cycle`; one turn's timing → `sequence`.
 
 ### AI & agents
 

package/templates/skill/reference/blocks/flows.md

@@ -31,13 +31,13 @@ per block; the density check warns past 40 spans. `sequence` for order, not dura
 States on a grid joined by event arrows, plus a transition table. Answers: what
 states can it be in, and what moves it? Give it one `kind: start` state and mark
 `terminal` states. `state`, not `flow`, for one object's discrete modes.
-#### `flow` — flowchart with decisions
-Start, process, decision, and end nodes with labelled edges; `variant: dag`
-frames it as a pipeline. Answers: what happens next, and what if the check
-fails? Flows run across, not down: the main path on `col` 1, 2, 3, branches
-on `row: 2`. Omit `col`/`row` for auto-layout (`dir: TB` works only there).
-A label that starts with no / fail / error / reject renders red. `groups`
-draw dashed zones over cell ranges. `flow`, not `sequence`, for branching.
+#### `flow` — flowchart with decisions, incl. AI workflows
+Start, process, decision, end, and AI nodes (`kind: agent / llm / tool /
+human / memory`, each with its chip); `variant: dag` frames a pipeline.
+Answers: what happens next, what if the check fails, which step is a model,
+a tool, or a person? Main path on `col` 1, 2, 3, branches on `row: 2`; omit
+`col`/`row` for auto-layout. A no / fail / error label renders red. `flow`,
+not `sequence`, for branching; `flow`, not `agentloop`, for AI workflows.
 #### `dfd` — data-flow diagram
 External entities, numbered processes, and stores joined by labelled data
 flows. Answers: where does the data come from, and where does it land?

package/templates/skill/reference/recipes.md

@@ -48,7 +48,25 @@ window? · What does a real run look like?
 7. `trace` — one real transcript, evidence the loop behaves as drawn.
 8. `callout` — the safety boundary the agent cannot cross.
 
-Rejected: `flow` (the loop is the primitive here, not a branch chart).
+Rejected: `flow` for the loop itself (the loop is the primitive, not a
+branch chart) — but a multi-step AI *workflow* is the next recipe.
+
+## AI workflow (RAG, routing, multi-agent, generate → check → repair)
+
+Reader questions: What are the steps? · Which step is a model, a tool, a
+person, or memory? · Where does it branch, retry, or stop?
+
+1. `meta` — the workflow's name and the outcome it produces.
+2. Prose — the trigger and the stop condition in two sentences.
+3. `flow` — the workflow as the request describes it: `kind: llm` for model
+   calls, `agent` for autonomous steps, `tool` for retrieval / APIs / code,
+   `human` for review gates, `memory` for stores, `decision` for routers and
+   checks, `-x->` for the repair path. Shape it from the ask; never reuse a
+   generic loop.
+4. `swimlane` — instead of `flow` when several agents or teams own steps.
+5. `cycle` — the improve-and-re-evaluate loop, when there is one.
+6. `context` or `envelope` — the budget: tokens per turn, or cost per run.
+7. `callout` — what the workflow must never do on its own.
 
 ## Frontend architecture