ptxiagram 0.2.0 → 0.3.0

package/README.md

@@ -1,13 +1,13 @@
 # ptxiagram
 
-**Generate architecture and workflow diagrams as native, editable PowerPoint shapes — not an embedded image.**
+**Generate architecture, workflow, and sequence diagrams as native, editable PowerPoint shapes — not an embedded image.**
 
-> Built with [Claude Code](https://claude.com/claude-code) — from the initial prototype through the pptxgenjs/Hancom Office compatibility investigation, the JSON schema design, the layout validator, and this package's release automation. See the [commit history](https://github.com/hiio420official/ptxiagram/commits/main) for the build process.
+> Built with [Claude Code](https://claude.com/claude-code) (Claude Sonnet 5) — from the initial prototype through the pptxgenjs/Hancom Office compatibility investigation, the JSON schema design, the layout validator, and this package's release automation. See the [commit history](https://github.com/hiio420official/ptxiagram/commits/main) for the build process.
 
 ptxiagram is an agent skill for Claude (and a standalone CLI/library) that turns a plain-English description of a system or process into a `.pptx` slide built from real PowerPoint shapes: rectangles, cylinders, clouds, connectors, text boxes. Anyone can open the result in PowerPoint — or Hancom 한쇼 — and click a box to change its color, text, or position, because it *is* a box, not a picture of one.
 
 - **Native shapes, not a picture** — every box and arrow is a real PPTX shape, editable after generation
-- **Three diagram types today** — `workflow` (swimlanes, happy-path flows), `architecture` (free-placed components, trust boundaries, hub-and-spoke), and `sequence` (participants + lifelines, API call chains)
+- **Five diagram types today** — `workflow` (swimlanes, happy-path flows), `architecture` (free-placed components, trust boundaries, hub-and-spoke), `sequence` (participants + lifelines, API call chains), `dataflow` (stage-to-stage pipelines with PII/lineage annotations), and `lifecycle` (state machines with terminal outcomes)
 - **A validator that catches real layout bugs before rendering** — node overlap, labels wider than their shape, and connectors that cut through an unrelated node all fail loudly with a specific fix, instead of shipping a broken-looking slide
 - **Ships a Hancom Office compatibility fix** — every generated file is post-processed to strip a documented PptxGenJS defect that PowerPoint silently repairs but Hancom's 한쇼 flags as a corrupted document (see below)
 - **Route presets instead of hand-computed coordinates** — `straight`, `drop`, `elbow-right`, `arc-over-top` cover swimlane transitions, hub-and-spoke fan-out, and routing around a boundary box
@@ -32,6 +32,11 @@ Use ptxiagram to make a workflow diagram of our incident response process,
 with a lane per team, so I can paste it into the postmortem deck.
 ```
 
+```text
+Use ptxiagram to draw a sequence diagram of this API's cache-fallback path,
+from request to response, for the engineering review deck.
+```
+
 The agent reads `SKILL.md`, writes a small JSON file describing your nodes and
 edges, and runs the CLI to produce a `.pptx` with real, editable shapes.
 
@@ -58,7 +63,7 @@ await renderWorkflow("my-diagram.workflow.json", "out.pptx");
 
 `render` validates the input (schema + layout) before writing anything, and always repairs the output for Hancom Office compatibility. `check` confirms the repair took, dumps every embedded text run for a spelling/content spot-check, and — if LibreOffice is installed — writes a PNG preview for a quick visual check.
 
-See [`SKILL.md`](SKILL.md) for the full JSON shape of both diagram types, the node-type → shape/color mapping, and the route presets.
+See [`SKILL.md`](SKILL.md) for the full JSON shape of all five diagram types, the node-type → shape/color mapping, and the route presets.
 
 ## Why every file gets repaired
 

package/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: ptxiagram
-description: Create architecture, workflow, and sequence diagrams as native, editable PowerPoint shapes (real rectangles, connectors, and text boxes a user can click and restyle in PowerPoint or Hancom 한쇼) instead of an embedded image. Accepts a plain-language description, turns it into a small JSON file, and renders it with pptxgenjs. Use when the user asks for a diagram, architecture drawing, process flow, or API call sequence that needs to end up inside a .pptx deck or a Korean-office-suite-compatible presentation - not when they just want a standalone image or an HTML/web diagram (use an SVG-based diagram tool for that instead).
+description: Create architecture, workflow, sequence, dataflow, and lifecycle diagrams as native, editable PowerPoint shapes (real rectangles, connectors, and text boxes a user can click and restyle in PowerPoint or Hancom 한쇼) instead of an embedded image. Accepts a plain-language description, turns it into a small JSON file, and renders it with pptxgenjs. Use when the user asks for a diagram, architecture drawing, process flow, API call sequence, data pipeline, or state machine that needs to end up inside a .pptx deck or a Korean-office-suite-compatible presentation - not when they just want a standalone image or an HTML/web diagram (use an SVG-based diagram tool for that instead).
 license: MIT
 metadata:
-  version: "0.2.0"
+  version: "0.3.0"
   status: prototype
   based_on: "gitbrent/PptxGenJS (MIT)"
 ---
@@ -52,6 +52,8 @@ validation and the embedded-text dump, just no rendered preview image).
 | `workflow` | Cross-team processes, approval chains, anything with swimlanes and a happy path | `schemas/workflow.schema.json` |
 | `architecture` | System components, services, datastores, trust boundaries, hub-and-spoke integrations | `schemas/architecture.schema.json` |
 | `sequence` | API call chains, request/response traces, cache-fallback flows — up to 6 participants, up to 9 messages | `schemas/sequence.schema.json` |
+| `dataflow` | Data pipelines, ETL/ELT, PII/lineage annotations, stage-to-stage flows | `schemas/dataflow.schema.json` |
+| `lifecycle` | State machines, status transitions, terminal outcomes (same JSON shape as `workflow`) | `schemas/lifecycle.schema.json` |
 
 ## The loop
 
@@ -60,6 +62,8 @@ validation and the embedded-text dump, just no rendered preview image).
    - `examples/onboarding.workflow.json`
    - `examples/order-processing.architecture.json`
    - `examples/cache-miss.sequence.json`
+   - `examples/product-analytics.dataflow.json`
+   - `examples/agent-run.lifecycle.json`
 2. Write `<name>.<type>.json`.
 3. Render:
    ```bash
@@ -153,12 +157,59 @@ explicit `y` field. Up to 9 messages without `cards`, ~6 with (cards need
 room at the bottom, so the lifeline gets shorter). Self-messages (same
 `from`/`to`) aren't supported yet.
 
+## Dataflow JSON shape
+
+```json
+{
+  "schema_version": 1,
+  "diagram_type": "dataflow",
+  "meta": { "title": "...", "output": "out.pptx" },
+  "stages": [{ "label": "Sources" }, { "label": "Ingest" }],
+  "nodes": [
+    { "id": "web", "type": "frontend", "label": "웹 앱", "stage": 0, "row": 0 }
+  ],
+  "flows": [
+    { "from": "web", "to": "queue", "label": "이벤트 전송", "classification": "PII touch", "variant": "security" }
+  ],
+  "cards": []
+}
+```
+
+**Layout budget**: up to 5 stages (columns, 2.6in apart) x 5 rows (fixed y
+positions). `flow.label` is required; `classification` is optional
+free-text rendered in parentheses after the label (e.g. "PII touch",
+"non-PII", "approved only") for sensitivity/lineage annotations. Route is
+picked automatically — `straight` when both ends share a row, `elbow-right`
+otherwise — so flows don't take a `route` field.
+
+## Lifecycle JSON shape
+
+Structurally identical to the workflow schema (same `lanes`/`nodes`/`edges`
+shape, same layout budget) — only `diagram_type` differs. Convention: a
+`main` lane for the happy-path states and a `terminal` lane for end states.
+
+```json
+{
+  "schema_version": 1,
+  "diagram_type": "lifecycle",
+  "meta": { "title": "...", "output": "out.pptx" },
+  "lanes": [{ "id": "main", "label": "실행 단계" }, { "id": "terminal", "label": "종료 결과" }],
+  "nodes": [
+    { "id": "queued", "lane": "main", "col": 0, "type": "neutral", "label": "대기 중" },
+    { "id": "completed", "lane": "terminal", "col": 3, "type": "success", "label": "완료" }
+  ],
+  "edges": [{ "from": "queued", "to": "completed", "variant": "emphasis", "route": "drop" }]
+}
+```
+
 ## Node types
 
 `client` `frontend` `neutral` `backend` `database` `cache` `queue`
-`external` `security` `decision` — each maps to a shape preset (ellipse,
-rect, roundRect, can/cylinder, hexagon, cube, cloud, diamond) and a color
-pair. Pick by role, not by desired color.
+`external` `security` `decision` `active` `waiting` `success` `failure` —
+each maps to a shape preset (ellipse, rect, roundRect, can/cylinder,
+hexagon, cube, cloud, diamond) and a color pair. The last four
+(`active`/`waiting`/`success`/`failure`) exist for `lifecycle` states;
+pick by role, not by desired color.
 
 ## Route presets
 
@@ -195,8 +246,11 @@ this automatically; `check` verifies it actually happened. Source:
 
 ## What's not built yet
 
-- `dataflow`, `lifecycle` diagram types (`workflow`, `architecture`, and
-  `sequence` exist so far)
 - No CJK exact-metrics font measurement — the label-width check is a
   conservative estimate, not real glyph widths
 - Sequence self-messages (a participant messaging itself)
+- No label-vs-label collision detection — two edges converging on the same
+  node from different rows can still end up with close (though no longer
+  overlapping, after the `elbow-right` label-anchor fix) labels in a busy
+  diagram; the validator catches label-vs-*shape* and edge-vs-*node*
+  collisions, not label-vs-label

package/bin/cli.mjs

@@ -8,11 +8,19 @@ import JSZip from "jszip";
 import { renderWorkflow } from "../renderers/workflow/render-workflow.mjs";
 import { renderArchitecture } from "../renderers/architecture/render-architecture.mjs";
 import { renderSequence } from "../renderers/sequence/render-sequence.mjs";
+import { renderDataflow } from "../renderers/dataflow/render-dataflow.mjs";
+import { renderLifecycle } from "../renderers/lifecycle/render-lifecycle.mjs";
 import { validateAll } from "../lib/validate.mjs";
 
 const execFileAsync = promisify(execFile);
 
-const RENDERERS = { workflow: renderWorkflow, architecture: renderArchitecture, sequence: renderSequence };
+const RENDERERS = {
+  workflow: renderWorkflow,
+  architecture: renderArchitecture,
+  sequence: renderSequence,
+  dataflow: renderDataflow,
+  lifecycle: renderLifecycle,
+};
 
 function usage() {
   console.log(`Usage:
@@ -21,7 +29,7 @@ function usage() {
   cli check <output.pptx>
   cli doctor
 
-Types: workflow, architecture, sequence`);
+Types: workflow, architecture, sequence, dataflow, lifecycle`);
 }
 
 async function cmdRender(type, inputPath, outputPath) {

package/examples/agent-run.lifecycle.json

@@ -0,0 +1,26 @@
+{
+  "schema_version": 1,
+  "diagram_type": "lifecycle",
+  "meta": {
+    "title": "에이전트 실행 라이프사이클",
+    "subtitle": "상태와 종료 결과",
+    "output": "test/output/agent-run.schema-driven.pptx"
+  },
+  "lanes": [
+    { "id": "main", "label": "실행 단계" },
+    { "id": "terminal", "label": "종료 결과" }
+  ],
+  "nodes": [
+    { "id": "queued", "lane": "main", "col": 0, "type": "neutral", "label": "대기 중", "sublabel": "큐에 등록됨" },
+    { "id": "running", "lane": "main", "col": 1, "type": "active", "label": "실행 중", "sublabel": "작업 처리" },
+    { "id": "reviewing", "lane": "main", "col": 3, "type": "waiting", "label": "승인 대기", "sublabel": "휴먼 리뷰" },
+    { "id": "completed", "lane": "terminal", "col": 3, "type": "success", "label": "완료" },
+    { "id": "failed", "lane": "terminal", "col": 5, "type": "failure", "label": "실패", "sublabel": "재시도 필요" }
+  ],
+  "edges": [
+    { "from": "queued", "to": "running", "variant": "default", "route": "straight" },
+    { "from": "running", "to": "reviewing", "variant": "default", "route": "straight" },
+    { "from": "reviewing", "to": "completed", "variant": "emphasis", "route": "drop", "label": "승인" },
+    { "from": "reviewing", "to": "failed", "variant": "security", "route": "drop", "label": "반려" }
+  ]
+}

package/examples/product-analytics.dataflow.json

@@ -0,0 +1,30 @@
+{
+  "schema_version": 1,
+  "diagram_type": "dataflow",
+  "meta": {
+    "title": "제품 분석 데이터 파이프라인",
+    "subtitle": "이벤트 수집 → 적재 → 소비",
+    "output": "test/output/product-analytics.schema-driven.pptx"
+  },
+  "stages": [
+    { "label": "Sources" },
+    { "label": "Ingest" },
+    { "label": "Store" },
+    { "label": "Consumers" }
+  ],
+  "nodes": [
+    { "id": "web", "type": "frontend", "label": "웹 앱", "sublabel": "clickstream", "stage": 0, "row": 0 },
+    { "id": "mobile", "type": "frontend", "label": "모바일 앱", "sublabel": "clickstream", "stage": 0, "row": 1 },
+    { "id": "queue", "type": "queue", "label": "이벤트 큐", "sublabel": "Kafka", "stage": 1, "row": 0 },
+    { "id": "warehouse", "type": "database", "label": "데이터 웨어하우스", "sublabel": "BigQuery", "stage": 2, "row": 0 },
+    { "id": "dashboard", "type": "external", "label": "대시보드", "sublabel": "내부 분석팀", "stage": 3, "row": 0 },
+    { "id": "ml", "type": "external", "label": "추천 모델", "sublabel": "배치 학습", "stage": 3, "row": 1 }
+  ],
+  "flows": [
+    { "from": "web", "to": "queue", "label": "이벤트 전송", "classification": "PII touch", "variant": "security" },
+    { "from": "mobile", "to": "queue", "label": "이벤트 전송", "classification": "PII touch", "variant": "security" },
+    { "from": "queue", "to": "warehouse", "label": "적재", "classification": "approved only", "variant": "default" },
+    { "from": "warehouse", "to": "dashboard", "label": "집계 쿼리", "classification": "non-PII", "variant": "default" },
+    { "from": "warehouse", "to": "ml", "label": "피처 추출", "classification": "non-PII", "variant": "dashed" }
+  ]
+}

package/index.mjs

@@ -1,11 +1,14 @@
 export { renderWorkflow } from "./renderers/workflow/render-workflow.mjs";
 export { renderArchitecture } from "./renderers/architecture/render-architecture.mjs";
 export { renderSequence } from "./renderers/sequence/render-sequence.mjs";
+export { renderDataflow } from "./renderers/dataflow/render-dataflow.mjs";
+export { renderLifecycle } from "./renderers/lifecycle/render-lifecycle.mjs";
 export {
   validateAll,
   validateSchema,
   validateWorkflowLayout,
   validateArchitectureLayout,
   validateSequenceLayout,
+  validateDataflowLayout,
 } from "./lib/validate.mjs";
 export { repairPptx } from "./lib/repair-pptx.mjs";

package/lib/layout.mjs

@@ -70,6 +70,33 @@ export function computeSequenceLayout(raw) {
   return { participantBoxes, centerX, messageYs, lifelineBottom, cardsY };
 }
 
+export const DATAFLOW_LAYOUT = {
+  STAGE_X0: 1.7, STAGE_GAP: 2.6,
+  ROW_Y: [1.3, 2.5, 3.7, 4.9, 6.1],
+  NODE_W: 1.6, NODE_H: 0.85,
+  STAGE_LABEL_Y: 0.95,
+};
+
+// Shared by the dataflow renderer and validator so route selection can
+// never drift between what's drawn and what's checked.
+export function sameRow(a, b) {
+  return Math.abs(a.y - b.y) < 0.05;
+}
+
+export function computeDataflowLayout(raw) {
+  const L = DATAFLOW_LAYOUT;
+  const stageCenterX = raw.stages.map((_, i) => L.STAGE_X0 + i * L.STAGE_GAP);
+  const nodeBoxes = {};
+  for (const n of raw.nodes) {
+    const cx = stageCenterX[n.stage];
+    if (cx === undefined) throw new Error(`Node "${n.id}" references unknown stage index ${n.stage}`);
+    const y = L.ROW_Y[n.row];
+    if (y === undefined) throw new Error(`Node "${n.id}" references unknown row index ${n.row}`);
+    nodeBoxes[n.id] = { x: cx - L.NODE_W / 2, y, w: L.NODE_W, h: L.NODE_H };
+  }
+  return { nodeBoxes, stageCenterX };
+}
+
 const BOUNDARY_PAD = 0.3;
 
 export function computeArchitectureLayout(raw) {

package/lib/routes.mjs

@@ -65,7 +65,10 @@ export function computeSegments(from, to, opts = {}) {
         { ...boxFromPoints({ x: midX, y: Math.min(a.y, b.y) }, { x: midX, y: Math.max(a.y, b.y) }), arrow: false },
         { ...boxFromPoints({ x: midX, y: b.y }, b), arrow: true },
       ],
-      labelAnchor: label ? { x: midX - 0.6, y: b.y, w: 1.2 } : null,
+      // anchored at the jog's own midpoint (like "drop" does), not at
+      // either endpoint's row -- otherwise this collides with a sibling
+      // "straight" edge whose label sits right at the target's row
+      labelAnchor: label ? { x: midX - 0.6, y: (a.y + b.y) / 2, w: 1.2 } : null,
     };
   }
 

package/lib/shapes.mjs

@@ -12,6 +12,11 @@ export const NODE_TYPES = {
   external: { shape: "cloud", fill: "FEF3C7", stroke: "F59E0B" },
   security: { shape: "roundRect", fill: "FFE4E6", stroke: "F43F5E" },
   decision: { shape: "diamond", fill: "FFE4E6", stroke: "F43F5E" },
+  // lifecycle-diagram states
+  active: { shape: "roundRect", fill: "DBEAFE", stroke: "3B82F6" },
+  waiting: { shape: "roundRect", fill: "FEF3C7", stroke: "F59E0B" },
+  success: { shape: "roundRect", fill: "D1FAE5", stroke: "10B981" },
+  failure: { shape: "roundRect", fill: "FFE4E6", stroke: "F43F5E" },
 };
 
 export const FONT = "맑은 고딕";

package/lib/validate.mjs

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import Ajv2020 from "ajv/dist/2020.js";
-import { computeWorkflowLayout, computeArchitectureLayout, computeSequenceLayout, SLIDE_W, SLIDE_H } from "./layout.mjs";
+import { computeWorkflowLayout, computeArchitectureLayout, computeSequenceLayout, computeDataflowLayout, sameRow, SLIDE_W, SLIDE_H } from "./layout.mjs";
 import { computeSegments } from "./routes.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -64,7 +64,7 @@ function offSlide(box) {
   return box.x < 0 || box.y < 0 || box.x + box.w > SLIDE_W || box.y + box.h > SLIDE_H;
 }
 
-function checkCommon({ problems, ids, boxes, labelOf, fontSizePt, edgesOrConns, resolveEndpoints, edgeLabel }) {
+function checkCommon({ problems, ids, boxes, labelOf, fontSizePt, edgesOrConns, resolveEndpoints, edgeLabel, resolveRoute = (e) => e.route || "straight" }) {
   for (const id of ids) {
     const box = boxes[id];
     const label = labelOf(id);
@@ -89,7 +89,7 @@ function checkCommon({ problems, ids, boxes, labelOf, fontSizePt, edgesOrConns,
     const { from, to } = resolveEndpoints(e);
     if (!from || !to) continue; // unknown-id errors surface from the renderer/schema instead
     const { segments } = computeSegments(from, to, {
-      route: e.route || "straight", bias: e.bias, clearY: e.clearY, label: e.label,
+      route: resolveRoute(e, from, to), bias: e.bias, clearY: e.clearY, label: e.label,
     });
     for (const id of ids) {
       if (id === e.from || id === e.to) continue;
@@ -133,6 +133,22 @@ export function validateArchitectureLayout(raw) {
   });
 }
 
+export function validateDataflowLayout(raw) {
+  const { nodeBoxes } = computeDataflowLayout(raw);
+  const labelOf = (id) => raw.nodes.find((n) => n.id === id).label;
+  return checkCommon({
+    problems: [],
+    ids: Object.keys(nodeBoxes),
+    boxes: nodeBoxes,
+    labelOf,
+    fontSizePt: 12.5,
+    edgesOrConns: raw.flows,
+    resolveEndpoints: (f) => ({ from: nodeBoxes[f.from], to: nodeBoxes[f.to] }),
+    edgeLabel: (f) => `Flow "${f.from}"->"${f.to}"`,
+    resolveRoute: (f, from, to) => (from && to && sameRow(from, to) ? "straight" : "elbow-right"),
+  });
+}
+
 export function validateSequenceLayout(raw) {
   const problems = [];
   const { participantBoxes, messageYs, lifelineBottom } = computeSequenceLayout(raw);
@@ -176,7 +192,9 @@ export function validateSequenceLayout(raw) {
 export async function validateAll(type, raw) {
   await validateSchema(type, raw);
   if (type === "workflow") return validateWorkflowLayout(raw);
+  if (type === "lifecycle") return validateWorkflowLayout(raw); // same JSON shape as workflow
   if (type === "architecture") return validateArchitectureLayout(raw);
   if (type === "sequence") return validateSequenceLayout(raw);
+  if (type === "dataflow") return validateDataflowLayout(raw);
   throw new Error(`Unknown diagram type: ${type}`);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ptxiagram",
-  "version": "0.2.0",
-  "description": "Generate native, editable PowerPoint (PPTX) architecture, workflow, and sequence diagrams from a small JSON file — real shapes and connectors, not an embedded image. Ships with a Claude Skill (SKILL.md) and a CLI.",
+  "version": "0.3.0",
+  "description": "Generate native, editable PowerPoint (PPTX) architecture, workflow, sequence, dataflow, and lifecycle diagrams from a small JSON file — real shapes and connectors, not an embedded image. Ships with a Claude Skill (SKILL.md) and a CLI.",
   "type": "module",
   "main": "index.mjs",
   "bin": {
@@ -18,7 +18,7 @@
   ],
   "scripts": {
     "doctor": "node bin/cli.mjs doctor",
-    "test": "node test/render-workflow.test.mjs && node test/render-architecture.test.mjs && node test/render-sequence.test.mjs && node test/validate.test.mjs && node test/workflow-lib-smoke.test.mjs"
+    "test": "node test/render-workflow.test.mjs && node test/render-architecture.test.mjs && node test/render-sequence.test.mjs && node test/render-dataflow.test.mjs && node test/render-lifecycle.test.mjs && node test/validate.test.mjs && node test/workflow-lib-smoke.test.mjs"
   },
   "keywords": [
     "pptx",
@@ -28,6 +28,8 @@
     "architecture-diagram",
     "workflow-diagram",
     "sequence-diagram",
+    "dataflow-diagram",
+    "lifecycle-diagram",
     "hancom",
     "hanshow",
     "office-automation"

package/renderers/dataflow/render-dataflow.mjs

@@ -0,0 +1,73 @@
+import pptxgen from "pptxgenjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { drawNode, drawCards, FONT, EDGE_VARIANTS } from "../../lib/shapes.mjs";
+import { connector } from "../../lib/routes.mjs";
+import { repairPptx } from "../../lib/repair-pptx.mjs";
+import { validateSchema, validateDataflowLayout } from "../../lib/validate.mjs";
+import { computeDataflowLayout, DATAFLOW_LAYOUT, sameRow } from "../../lib/layout.mjs";
+
+export async function renderDataflow(inputPath, outputPath) {
+  const raw = JSON.parse(await fs.readFile(inputPath, "utf8"));
+  await validateSchema("dataflow", raw);
+
+  const { nodeBoxes, stageCenterX } = computeDataflowLayout(raw);
+  const problems = validateDataflowLayout(raw);
+  if (problems.length) {
+    throw new Error(`Dataflow layout validation failed:\n- ${problems.join("\n- ")}`);
+  }
+
+  const pptx = new pptxgen();
+  pptx.defineLayout({ name: "WIDE", width: 13.33, height: 7.5 });
+  pptx.layout = "WIDE";
+  const slide = pptx.addSlide();
+
+  slide.addText(raw.meta.title, {
+    x: 0.4, y: 0.2, w: 12.5, h: 0.5,
+    fontFace: FONT, fontSize: 20, bold: true, color: "0F172A",
+  });
+  if (raw.meta.subtitle) {
+    slide.addText(raw.meta.subtitle, {
+      x: 0.4, y: 0.65, w: 12.5, h: 0.3,
+      fontFace: FONT, fontSize: 11, color: "64748B",
+    });
+  }
+
+  raw.stages.forEach((s, i) => {
+    slide.addText(s.label, {
+      x: stageCenterX[i] - 1.0, y: DATAFLOW_LAYOUT.STAGE_LABEL_Y, w: 2.0, h: 0.3,
+      align: "center", fontFace: FONT, fontSize: 11, bold: true, color: "64748B",
+    });
+  });
+
+  for (const n of raw.nodes) {
+    drawNode(slide, { ...nodeBoxes[n.id], label: n.label, sublabel: n.sublabel, type: n.type, tag: n.tag });
+  }
+
+  for (const f of raw.flows) {
+    const variant = EDGE_VARIANTS[f.variant || "default"];
+    const from = nodeBoxes[f.from], to = nodeBoxes[f.to];
+    if (!from) throw new Error(`Flow references unknown node "${f.from}"`);
+    if (!to) throw new Error(`Flow references unknown node "${f.to}"`);
+    const label = f.classification ? `${f.label} (${f.classification})` : f.label;
+    connector(slide, from, to, {
+      color: variant.color, dashed: variant.dashed, label,
+      route: sameRow(from, to) ? "straight" : "elbow-right",
+    });
+  }
+
+  if (raw.cards && raw.cards.length) {
+    drawCards(slide, raw.cards, 6.5);
+  }
+
+  slide.addText("Made with a Claude Skill · native PPTX shapes, editable in PowerPoint", {
+    x: 0.4, y: 7.15, w: 12.5, h: 0.3,
+    fontFace: FONT, fontSize: 8, color: "94A3B8", italic: true,
+  });
+
+  const outFile = outputPath || raw.meta.output || "output.pptx";
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
+  await pptx.writeFile({ fileName: outFile });
+  await repairPptx(outFile);
+  return outFile;
+}

package/renderers/lifecycle/render-lifecycle.mjs

@@ -0,0 +1,10 @@
+import { renderWorkflow } from "../workflow/render-workflow.mjs";
+
+// lifecycle.schema.json is structurally identical to workflow.schema.json
+// (lanes/nodes/edges, same layout budget) -- it only differs in its
+// diagram_type const and typical usage (states + terminal outcomes instead
+// of process steps), so it reuses the workflow renderer wholesale rather
+// than duplicating the same ~70 lines under a different file name.
+export async function renderLifecycle(inputPath, outputPath) {
+  return renderWorkflow(inputPath, outputPath, "lifecycle");
+}

package/renderers/workflow/render-workflow.mjs

@@ -7,9 +7,14 @@ import { repairPptx } from "../../lib/repair-pptx.mjs";
 import { validateSchema, validateWorkflowLayout } from "../../lib/validate.mjs";
 import { computeWorkflowLayout } from "../../lib/layout.mjs";
 
-export async function renderWorkflow(inputPath, outputPath) {
+// `schemaType` lets renderLifecycle (schemas/lifecycle.schema.json) reuse
+// this renderer as-is: lifecycle JSON is structurally identical to
+// workflow's (lanes/nodes/edges), it just validates against its own
+// diagram_type const and typically uses the start/active/waiting/
+// success/failure node types instead of workflow's process-step ones.
+export async function renderWorkflow(inputPath, outputPath, schemaType = "workflow") {
   const raw = JSON.parse(await fs.readFile(inputPath, "utf8"));
-  await validateSchema("workflow", raw);
+  await validateSchema(schemaType, raw);
 
   const { laneBoxes, nodeBoxes, cardsY } = computeWorkflowLayout(raw);
   const problems = validateWorkflowLayout(raw);

package/schemas/common.schema.json

@@ -15,7 +15,7 @@
       "maxItems": 2
     },
     "nodeType": {
-      "enum": ["client", "frontend", "neutral", "backend", "database", "cache", "queue", "external", "security", "decision"]
+      "enum": ["client", "frontend", "neutral", "backend", "database", "cache", "queue", "external", "security", "decision", "active", "waiting", "success", "failure"]
     },
     "route": {
       "enum": ["straight", "drop", "elbow-right", "arc-over-top"]

package/schemas/dataflow.schema.json

@@ -0,0 +1,80 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://claude-skills/pptx-diagram/schemas/dataflow.schema.json",
+  "title": "Native PPTX Dataflow Diagram",
+  "description": "Nodes sit in a stage (column, left-to-right) x row (0-4) grid. Flows carry a mandatory label plus an optional classification (e.g. 'PII touch', 'non-PII') for sensitivity/lineage annotations.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "diagram_type", "meta", "stages", "nodes", "flows"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "diagram_type": { "const": "dataflow" },
+    "meta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["title"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "subtitle": { "type": "string" },
+        "output": { "type": "string" }
+      }
+    },
+    "stages": {
+      "type": "array",
+      "minItems": 2,
+      "maxItems": 5,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["label"],
+        "properties": { "label": { "type": "string", "minLength": 1 } }
+      }
+    },
+    "nodes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "type", "label", "stage", "row"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "type": { "$ref": "common.schema.json#/$defs/nodeType" },
+          "label": { "type": "string", "minLength": 1 },
+          "sublabel": { "type": "string" },
+          "tag": { "type": "string" },
+          "stage": { "type": "integer", "minimum": 0, "maximum": 4 },
+          "row": { "type": "integer", "minimum": 0, "maximum": 4 }
+        }
+      }
+    },
+    "flows": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["from", "to", "label"],
+        "properties": {
+          "from": { "$ref": "common.schema.json#/$defs/id" },
+          "to": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string", "minLength": 1 },
+          "classification": { "type": "string" },
+          "variant": { "enum": ["default", "emphasis", "security", "dashed"] }
+        }
+      }
+    },
+    "cards": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["title", "items"],
+        "properties": {
+          "title": { "type": "string", "minLength": 1 },
+          "color": { "$ref": "common.schema.json#/$defs/hexColor" },
+          "items": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    }
+  }
+}

package/schemas/lifecycle.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://claude-skills/pptx-diagram/schemas/lifecycle.schema.json",
+  "title": "Native PPTX Lifecycle Diagram",
+  "description": "Structurally identical to the workflow schema (lanes/nodes/edges, same layout budget) -- use it for state machines instead of process flows. Convention: a 'main' lane for the happy-path states and a 'terminal' lane for end states, with node types start/active/waiting/success/failure.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "diagram_type", "meta", "lanes", "nodes", "edges"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "diagram_type": { "const": "lifecycle" },
+    "meta": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["title"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "subtitle": { "type": "string" },
+        "output": { "type": "string" }
+      }
+    },
+    "lanes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "label"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string", "minLength": 1 },
+          "height": { "type": "number", "minimum": 1.2, "maximum": 3, "description": "inches; default 1.75" }
+        }
+      }
+    },
+    "nodes": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "lane", "type", "label"],
+        "properties": {
+          "id": { "$ref": "common.schema.json#/$defs/id" },
+          "lane": { "$ref": "common.schema.json#/$defs/id" },
+          "col": { "type": "integer", "minimum": 0, "maximum": 5, "description": "slot index within the lane; auto-assigned to the next free slot if omitted" },
+          "type": { "$ref": "common.schema.json#/$defs/nodeType" },
+          "label": { "type": "string", "minLength": 1 },
+          "sublabel": { "type": "string" },
+          "tag": { "type": "string" },
+          "width": { "type": "number", "minimum": 0.6, "maximum": 1.85, "description": "inches; default 1.8, capped so it never exceeds one slot" },
+          "height": { "type": "number", "minimum": 0.5, "maximum": 1.5, "description": "inches; default 0.95" }
+        }
+      }
+    },
+    "edges": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["from", "to"],
+        "properties": {
+          "from": { "$ref": "common.schema.json#/$defs/id" },
+          "to": { "$ref": "common.schema.json#/$defs/id" },
+          "label": { "type": "string" },
+          "variant": { "enum": ["default", "emphasis", "security", "dashed"] },
+          "route": { "$ref": "common.schema.json#/$defs/route" },
+          "bias": { "type": "number", "minimum": 0.1, "maximum": 0.9 }
+        }
+      }
+    },
+    "cards": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["title", "items"],
+        "properties": {
+          "title": { "type": "string", "minLength": 1 },
+          "color": { "$ref": "common.schema.json#/$defs/hexColor" },
+          "items": { "type": "array", "items": { "type": "string" } }
+        }
+      }
+    }
+  }
+}