wand-decks-kit 0.9.0 → 0.10.0

package/PROMPT.md

@@ -11,6 +11,35 @@ is the workflow and the design system; the skill is the source of truth for comm
 ---
 
 
+
+## Session decks — the Kearney standard (0.10)
+
+`Wand_x_Kearney_SF_Leadership_Session_29Sep2026_v2.pptx` is the reference for a
+deck that is *run in a room*. What makes it that quality is not the slides
+alone:
+
+- **A spine.** Five Parts, each opened by a divider with a client-specific
+  *working question*, and a session slide that reads as a clock (minutes per
+  part). The kit: `divider` gains `part`, and uses the deck's own section art
+  (`divider-art.png`); `coDelivery` / `agenda` items gain `meta`.
+- **A run-of-show in the notes.** Every content slide carries its time window,
+  CORE when it carries the argument, what to say, and who in the room will test
+  it; the session slide carries checkpoints and what to cut if late. The kit:
+  `notes` on any slide, written through pptxgenjs `addNotes`.
+- **Backups behind the close**, hidden and uncounted. The kit: `backup: true`.
+- **Two slides every Wand session uses**: the today-vs-with-Wand flow (the
+  agents' steps filled) and the transformation timeline. The kit:
+  `flowCompare`, `timeline`.
+
+Where the reference is weaker than the kit, the kit wins: it embeds fonts
+subsetted (`saveSubsetFonts="1"`, which garbles digits in exported PDFs), and
+1,834 text runs are Calibri. `audit` flags both on it.
+
+**Edits are commands, not rewrites.** `wand.js show` and `wand.js edit` exist
+because a salesperson's changes are small and the old edit path cost two full
+copies of the spec in the chat. A spec's `confidential` now reaches the footer
+— it never did; every deck said STRICTLY CONFIDENTIAL.
+
 ## The guideline deck (0.9)
 
 Since 2026-09-23 the design source of truth is a real deck —

package/SKILL.md

@@ -4,7 +4,7 @@ description: Rebrand, merge, edit or author a PowerPoint deck on the Wand design
 compatibility: Requires Node.js 18+ and code execution enabled in claude.ai (Settings > Features). No network access needed - dependencies are bundled. Python 3 is used to read a source .pptx and to embed fonts; without it the kit can still author and check a deck, but the output will render in Arial on machines without Geist.
 license: Proprietary - Wand AI
 metadata:
-  version: "0.9.0"
+  version: "0.10.0"
 ---
 
 
@@ -34,16 +34,27 @@ output.
 
 Every path below is relative to the kit folder.
 
-A deck engine: 28 layouts, real font metrics, embedded Geist, and six gates that
-each catch something the others cannot.
+A deck engine: 35 layouts, real font metrics, embedded Geist, speaker notes,
+and gates that each catch something the others cannot.
 
-**Read `PROMPT.md` before making any design decision.** It is the source of
-truth on canvas, colour, type, layout choice and content rules. This file is
-only the operating procedure.
+## Read only what the job needs
+
+Sales teams run this. Every file you read and every spec you write is paid for
+in the chat, so the job decides the reading:
+
+| Job | Read | Never |
+|---|---|---|
+| Edit a deck this kit built | `node wand.js show <deck>` (one line per slide), then `show <deck> <n>` for the slide you change | read or rewrite the whole spec; read `PROMPT.md` |
+| Edit a deck built elsewhere | the slide you change, then `audit` | restyle anything unasked |
+| Rebuild, merge, author | `PROMPT.md` once, `work/PLAN.md`, `node wand.js layouts` | re-read them per slide |
+
+Look at the contact sheet once; open a single slide only where something looks
+off. `PROMPT.md` is the source of truth on design — read it for design
+decisions, not for edits.
 
 ## Available scripts
 
-- **`wand.js`** — the front door - doctor, rebuild, layouts, glyphs, validate, check, preview, ship, spec, inspect
+- **`wand.js`** — the front door - doctor, rebuild, layouts, glyphs, validate, check, preview, ship, show, edit, audit, spec, inspect
 - **`build.js`** — spec -> .pptx, or --check, or --preview
 - **`tools/extract.py`** — read a source deck: verbatim dump, geometry, analysis
 - **`embed_fonts.py`** — embed Geist unsubsetted, and carry the spec inside the deck
@@ -70,7 +81,7 @@ thing, and paid a full second pass. This is not optional for a rebuild, a merge
 or an adaptation; only "author from a brief" with fewer than eight slides may
 go straight to the spec.
 
-## The six jobs
+## The seven jobs
 
 ### Rebrand a deck they attached
 
@@ -139,13 +150,42 @@ partner slide". They want *that*, and nothing else touched.
 
 ### Edit a deck this kit built
 
+Decks built here carry their spec inside the file, so an edit is one command —
+not reading the spec, not writing it back:
+
 ```bash
-node wand.js spec <their-deck>.pptx work/deck.json
+node wand.js show  deck.pptx                 # one line per slide
+node wand.js show  deck.pptx 4               # slide 4's fields, only if you need them
+node wand.js edit  deck.pptx --set '1.tag=Presented to Acme  ·  6 October 2026' \
+                             --set 2.items.4.meta='40 min' \
+                             --set '7.notes.text=Lead with the Foundation phase.'
 ```
 
-Decks built here carry their own spec inside the file. Change only what was
-asked, then `ship`. If the deck carries no spec it was not built here — treat it
-as a rebrand.
+Paths are 1-based, the way the room counts: `2.items.4.meta` is slide 2, item 4.
+Also `--del N`, `--move N M`, `--add N '<slide json>'`, `--dry` to preview. The
+result is saved as the next version (`Deck_v2.pptx` → `Deck_v3.pptx`), every
+gate runs, the original is never overwritten. If `show` says the deck carries
+no spec, it was not built here — use the job above.
+
+### Build a session deck
+
+When the deck will be *run* in a room — a leadership session, a workshop, a
+partner meeting — give it the shape of the Kearney example (the reference for
+this kind of deck, `examples/session.json`):
+
+- **Cover** with `presentedTo`. **Session slide** next: `coDelivery` with a
+  `meta` duration on every item ("15 min") — the room reads it as a clock.
+- **Part dividers** (`divider` with `part: "Part II"` and `body: "Working
+  question: …"`) — one question per part, written for this client.
+- **Speaker notes on every content slide**: `notes: { time: "00:21 to 00:25",
+  core: true, text, watch }`. `time` is the run-of-show window; `core` marks the
+  slides that carry the argument; `watch` names who in the room will push. The
+  session slide's notes carry the checkpoints and what to cut if late.
+- **Backups after the closing**, `backup: true` — hidden, uncounted ("31 of 31",
+  not "of 34"), footer says BACKUP.
+
+Timings, attendee names and "watch for" lines come from the user or the brief.
+Never invent them — leave `notes` out rather than guess.
 
 ## Spend tool calls like they are metered — they are
 
@@ -213,6 +253,8 @@ combined one covers it.
 | `node wand.js check <spec>` | fit in real Geist, bounds, assets |
 | `node wand.js preview <spec>` | writes `preview/trace.js` for the browser preview |
 | `node wand.js inspect <deck>` | parts, relationships, embedded fonts |
+| `node wand.js show <deck> [n]` | the deck in one line per slide, or one slide's fields |
+| `node wand.js edit <deck> --set N.path=v` | change a kit-built deck in one command; saves `_vN+1`, runs every gate |
 | `node wand.js audit <deck> [--dump f]` | every spec-free gate on any .pptx, including the **brand** gate (fonts, colours, canvas, footer) — use on decks edited outside the kit |
 
 ## Deliver

package/build.js

@@ -30,16 +30,27 @@ function loadSpec(p) {
 /** Build the .pptx. */
 function build(spec, out) {
   const pres = W.newDeck(pptxgen);
-  const total = spec.slides.length;
+  // Backups are hidden and uncounted: the room sees 31 of 31, not 31 of 34.
+  const total = spec.slides.filter((x) => !x.backup).length;
+  let n = 0;
   spec.slides.forEach((sl, i) => {
     const fn = W[sl.layout];
     if (typeof fn !== "function") throw new Error(`slide ${i + 1}: unknown layout "${sl.layout}"`);
-    const args = { ...sl, n: i + 1, total };
+    const args = { ...sl, n: sl.backup ? null : ++n, total };
     if (!FULL_BLEED.has(sl.layout)) {
       args.deck = sl.deck || spec.deck;
       args.confidential = sl.confidential || spec.confidential;
     }
+    W.context({ confidential: args.confidential || "STRICTLY CONFIDENTIAL" });
+    const before = pres.slides.length;
     fn(pres, args);
+    // Not every layout returns its slide, so take the one it just added.
+    const slide = pres.slides.length > before ? pres.slides[pres.slides.length - 1] : null;
+    if (slide) {
+      const nt = W.notesText(sl.notes);
+      if (nt) slide.addNotes(nt);
+      if (sl.backup) slide.hidden = true;
+    }
   });
   return pres.writeFile({ fileName: out }).then(() => {
     console.log(`wrote ${out} (${total} slides)`);

package/docs/LAYOUTS.md

@@ -17,18 +17,21 @@ full-bleed three) `deck` / `n` / `total` for the footer.
 | Layout | Params | Use for |
 |---|---|---|
 | `cover` | `eyebrow, titleLines[], body, kickerPlain, kickerBold` | Slide 1. Dark, full bleed, no footer |
-| `divider` | `eyebrow, titleText, body` | Section breaks and the agenda. Keeps the tag, drops the footer |
+| `divider` | `eyebrow, titleText, body, part` | Section breaks and the agenda. Keeps the tag, drops the footer |
 | `closing` | `eyebrow, line1, line2, body, url` | Last slide. Centred, full bleed |
 
 ## Content
 
 | Layout | Params | Use for |
 |---|---|---|
-| `agenda` | `items[{title,body}]` | What we'll cover — 2–5 numbered cards (guideline S03) |
+| `agenda` | `items[{title,body,meta}]` | What we'll cover — 2–5 numbered cards (guideline S03) |
 | `team` | `items[{name,role,initials}]` | Who's in the room — headshot slot per person (guideline S02) |
 | `fourCards` | `items[{title,body}]` | Demo objectives, pillars — four titled cards under a lede (S12) |
 | `deliverColumns` | `columns[{heading,lead,body}]` | How we deliver — three flat columns with an accent bar (S14) |
-| `coDelivery` | `items[{title,body}]` | Numbered rows in two columns, up to six (S13) |
+| `coDelivery` | `items[{title,body,meta}]` | Numbered rows in two columns, up to six. With `meta: "15 min"` it is the session agenda (Kearney S02) |
+| `flowCompare` | `lanes[{label,caption,steps[{who,step,human}]}]` | Today vs with Wand — two lanes of 3–5 steps; the machine steps are filled (Kearney S08) |
+| `timeline` | `phases[{when,label,bullets}]` | A journey in 2–4 phases on a line (Kearney S16) |
+| — every layout — | `notes`, `backup` | Speaker notes (`{time, core, text, watch}` or a string); `backup: true` hides the slide after the close |
 | `threeUp` | `items[{eyebrow,title,pill,body,emph}], arrows` | 3 comparable things. `arrows: true` for a progression |
 | `fourUpIcon` | `items[{icon,title,body}], kickerText` | 4 attributes or capabilities |
 | `sixUpIcon` | `items[{icon,title,body}]` | 6 features. Don't use it three slides running |

package/examples/session.json

@@ -0,0 +1,92 @@
+{
+  "deck": "WAND × CLIENT · LEADERSHIP SESSION",
+  "confidential": "WAND · CONFIDENTIAL",
+  "slides": [
+    { "layout": "cover", "tag": "Presented to Client  ·  29 September 2026",
+      "titleLines": ["Expand human possibility", "beyond human capacity."],
+      "body": "For all of history, what organizations could accomplish was constrained by the number of people available to do the work. AI labor changes that.",
+      "presentedTo": ["First Last, Managing Partner", "First Last, Head of Transformation"],
+      "notes": { "text": "On screen while the room settles. Frame it the way the client asked: a working conversation about a change in the nature of production, not a product pitch." } },
+
+    { "layout": "coDelivery", "tag": "The session", "titleText": "A working conversation, not a presentation.",
+      "items": [
+        { "title": "When software becomes labor", "body": "The threshold between a tool and a worker.", "meta": "15 min" },
+        { "title": "The organization has to change", "body": "From the individual agent to the Hybrid Organization.", "meta": "10 min" },
+        { "title": "Why transformations succeed, or die", "body": "Resistance is operating-model design.", "meta": "10 min" },
+        { "title": "From architecture to production", "body": "Inside an agent, then one real process, live.", "meta": "35 min" },
+        { "title": "When capacity decouples from labor", "body": "From the firm to the economy.", "meta": "5 min" },
+        { "title": "Wand × Client", "body": "Designing the Hybrid Organization together.", "meta": "10 min" }
+      ],
+      "notes": { "time": "00:00, under one minute", "text": "Walk the spine, not the rows. 90 minutes core, then 30 minutes of open discussion. Checkpoints: 00:20 Part II, 00:40 Part IV, 01:15 Part V. If late, compress Part III and Part V — never the live walkthrough." } },
+
+    { "layout": "divider", "titleText": "When software becomes labor",
+      "part": "Part I", "body": "Working question: which of your problems are being treated as AI productivity when they are really a chance to add a new source of labor?",
+      "notes": { "time": "00:01 to 00:03", "text": "Read the working question aloud and leave it on screen. Do not answer it yet." } },
+
+    { "layout": "flowCompare", "tag": "Why three years of AI spend has not moved the operating line",
+      "titleText": "Every AI tool you own ends at a person.",
+      "lanes": [
+        { "label": "Today — AI as a tool", "caption": "Capacity = your people. Four of five steps wait on a person; that person is the ceiling.",
+          "steps": [ { "who": "Person", "step": "Notices", "human": true }, { "who": "Person", "step": "Gathers context", "human": true },
+                     { "who": "Person", "step": "Instructs", "human": true }, { "who": "AI", "step": "Drafts" },
+                     { "who": "Person", "step": "Checks", "human": true } ] },
+        { "label": "With Wand — AI as labor", "caption": "Capacity = people + agents. The person moves from every step to the one step that needs judgment.",
+          "steps": [ { "who": "Agent", "step": "Notices" }, { "who": "Agent", "step": "Plans" }, { "who": "Agent", "step": "Executes" },
+                     { "who": "Agent", "step": "Grades" }, { "who": "Manager", "step": "Approves", "human": true } ] }
+      ],
+      "notes": { "time": "00:11 to 00:14", "core": true, "text": "This is the difference between an efficiency programme and a capacity programme. Point at the top row: every step waits on a person.", "watch": "whoever owns the current copilot rollout — expect them to defend adoption numbers." } },
+
+    { "layout": "fourCards", "tag": "Agent behavior", "titleText": "A worker, not just a good tool.",
+      "subtitleText": "A tool responds to prompts. A worker pursues goals, decides what matters, acts within constraints, and is judged by outcomes.",
+      "items": [
+        { "title": "Pursues goals", "body": "Carries objectives and KPIs like any employee, and works toward them without being asked." },
+        { "title": "Decides what matters", "body": "Notices, prioritizes and plans inside the boundaries policy sets." },
+        { "title": "Is graded", "body": "Every output reviewed against a baseline agreed before it started." },
+        { "title": "Gets better", "body": "Banks what it learns, so a year in it is categorically better, not older." }
+      ],
+      "notes": { "time": "00:43 to 00:47", "core": true, "text": "Land the word 'worker'. Everything after this slide assumes the room accepts it." } },
+
+    { "layout": "divider", "titleText": "Why transformations die",
+      "part": "Part III", "body": "Working question: what would your methodology look like if org redesign, workforce redesign and agent deployment were one program, not three?",
+      "notes": { "time": "00:30 to 00:31" } },
+
+    { "layout": "timeline", "tag": "Transformation journey", "titleText": "The transformation timeline.",
+      "subtitleText": "From the starting line, month over month, compounding.",
+      "phases": [
+        { "when": "3–6 months", "label": "Foundation", "bullets": ["A core transformation team of 7–10 people", "One registry covering people and agents", "5–10 core processes rebuilt for the dual workforce", "Dozens of agents in production with named managers"] },
+        { "when": "6–12 months", "label": "Scale", "bullets": ["Agents across dozens of core functions", "Management structure rebalanced; spans widened", "Hundreds of agents in production"] },
+        { "when": "12–24 months", "label": "Accelerate", "bullets": ["Most processes designed for a dual workforce from the start", "Whole functions run by agent teams", "Cost per unit of work structurally below the market"] }
+      ],
+      "notes": { "time": "00:37 to 00:40", "core": true, "text": "Timelines are directional. The commitment is the Foundation phase; everything after it is earned by the telemetry." } },
+
+    { "layout": "deliverColumns", "tag": "The build", "titleText": "The client designs the transformation. Wand operates it.",
+      "subtitleText": "Who does each part, and how it is governed.",
+      "columns": [
+        { "heading": "1 · Change management", "lead": "Led by your people, supported by ours", "body": "A small core team who pick where to start and carry the early wins back." },
+        { "heading": "2 · Deployment", "lead": "Led by our solution architect with your technical team", "body": "Cloud, deployment model, security review, and reaching the systems you run." },
+        { "heading": "3 · Building the workforce", "lead": "Led by our forward-deployed engineers", "body": "Build the agents and processes with your team, then shift to supporting as your people take it on." }
+      ],
+      "notes": { "time": "01:23 to 01:25", "text": "Their methodology, our operating system. Say it in that order." } },
+
+    { "layout": "fourCards", "tag": "Next steps", "titleText": "What happens next.",
+      "subtitleText": "This room builds the momentum. The partnership work happens in a smaller session, with named owners and dates.",
+      "items": [
+        { "title": "Partnership session", "body": "Named leads on both sides; one process chosen and its baseline written down." },
+        { "title": "Architecture deep-dive", "body": "Under NDA, for your technology team: deployment posture, identity, audit." },
+        { "title": "Sandbox access", "body": "A governed environment your team can build in, with our engineers alongside." },
+        { "title": "First client reunion", "body": "Where the first agents in production are shown against the baseline." }
+      ],
+      "notes": { "time": "01:29 to 01:30", "text": "Leave the room with one date agreed. Anything else is a follow-up email." } },
+
+    { "layout": "closing", "line1": "Thank you.", "body": "The operating system for the human + agent workforce.", "url": "September 2026  |  Strictly Confidential" },
+
+    { "layout": "fourCards", "backup": true, "tag": "Why this is a category", "titleText": "Five advantages, not five features.",
+      "items": [
+        { "title": "Governance & orchestration", "body": "One policy, one identity, one audit trail across the whole estate." },
+        { "title": "Institutional IP", "body": "Every lesson compounds inside your perimeter, not ours." },
+        { "title": "Model agnostic", "body": "Any model, any cloud — no lock-in, sovereignty-friendly by design." },
+        { "title": "One registry", "body": "People and agents managed in the same system, by the same managers." }
+      ],
+      "notes": "BACKUP. Use only if the room asks why this is not another agent platform." }
+  ]
+}

package/examples/template.json

@@ -665,6 +665,106 @@
         }
       ]
     },
+    {
+      "layout": "flowCompare",
+      "tag": "Why three years of AI spend has not moved the operating line",
+      "titleText": "Every AI tool you own ends at a person.",
+      "lanes": [
+        {
+          "label": "Today — AI as a tool",
+          "caption": "Capacity = your people. Four of five steps wait on a person; that person is the ceiling.",
+          "steps": [
+            {
+              "who": "Person",
+              "step": "Notices",
+              "human": true
+            },
+            {
+              "who": "Person",
+              "step": "Gathers context",
+              "human": true
+            },
+            {
+              "who": "Person",
+              "step": "Instructs",
+              "human": true
+            },
+            {
+              "who": "AI",
+              "step": "Drafts"
+            },
+            {
+              "who": "Person",
+              "step": "Checks",
+              "human": true
+            }
+          ]
+        },
+        {
+          "label": "With Wand — AI as labor",
+          "caption": "Capacity = people + agents. The person moves from every step to the one step that needs judgment.",
+          "steps": [
+            {
+              "who": "Agent",
+              "step": "Notices"
+            },
+            {
+              "who": "Agent",
+              "step": "Plans"
+            },
+            {
+              "who": "Agent",
+              "step": "Executes"
+            },
+            {
+              "who": "Agent",
+              "step": "Grades"
+            },
+            {
+              "who": "Manager",
+              "step": "Approves",
+              "human": true
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "layout": "timeline",
+      "tag": "Transformation journey",
+      "titleText": "The transformation timeline.",
+      "subtitleText": "From the starting line, month over month, compounding.",
+      "phases": [
+        {
+          "when": "3–6 months",
+          "label": "Foundation",
+          "bullets": [
+            "A core transformation team of 7–10 people",
+            "One registry covering people and agents",
+            "5–10 core processes rebuilt for the dual workforce",
+            "Dozens of agents in production with named managers"
+          ]
+        },
+        {
+          "when": "6–12 months",
+          "label": "Scale",
+          "bullets": [
+            "Agents across dozens of core functions",
+            "Management structure rebalanced; spans widened",
+            "Hundreds of agents in production"
+          ]
+        },
+        {
+          "when": "12–24 months",
+          "label": "Accelerate",
+          "bullets": [
+            "Most processes designed for a dual workforce from the start",
+            "Whole functions run by agent teams",
+            "Cost per unit of work structurally below the market"
+          ]
+        }
+      ]
+    },
     {
       "layout": "closing",
       "eyebrow": "THE CLOSE",

package/lib/pdf.js

@@ -112,6 +112,20 @@ class Doc {
     return this;
   }
 
+  /**
+   * A filled triangle in its box, pointing up — or right when rotated 90°, the
+   * way a flow connector is drawn. Matches pptxgenjs's "triangle" + rotate.
+   */
+  triangle({ x, y, w, h, fill, rotate = 0 }) {
+    const o = this.page.ops;
+    const pts = rotate === 90
+      ? [[x, y], [x + w, y + h / 2], [x, y + h]]
+      : [[x, y + h], [x + w / 2, y], [x + w, y + h]];
+    o.push(`${rgb(fill || "000000")} rg`,
+      pts.map(([px, py], i) => `${num(px * PT)} ${num(this._y(py))} ${i ? "l" : "m"}`).join(" ") + " h f");
+    return this;
+  }
+
   line({ x1, y1, x2, y2, color = "000000", width = 0.75 }) {
     this.page.ops.push(`${rgb(color)} RG`, `${num(width)} w`,
       `${num(x1 * PT)} ${num(this._y(y1))} m ${num(x2 * PT)} ${num(this._y(y2))} l S`);

package/lib/render_pdf.js

@@ -152,6 +152,7 @@ function drawShape(d, sh) {
   const stroke = sh.line && sh.line.width ? (sh.line.color || "000000").replace(/^#/, "") : null;
   const box = { x: sh.x || 0, y: sh.y || 0, w: sh.w || 0, h: sh.h || 0 };
   if (sh.type === "ellipse") return d.ellipse({ ...box, fill, stroke, lineWidth: (sh.line && sh.line.width) || 0.75 });
+  if (sh.type === "triangle") return d.triangle({ ...box, fill, rotate: sh.rotate || 0 });
   d.rect({
     ...box, fill, stroke,
     lineWidth: (sh.line && sh.line.width) || 0.75,

package/lib/schema.js

@@ -27,6 +27,8 @@ const COMMON = {
   subtitleText: str({ note: "the lede under the title" }),
   deck: str({ note: "overrides the deck-level footer" }),
   confidential: str(),
+  notes: s("notes", { note: 'speaker notes — a string, or { time: "00:21 to 00:25", core: true, text, watch }' }),
+  backup: s("boolean", { note: "a hidden slide after the closing; its footer says BACKUP" }),
 };
 
 const L = {
@@ -43,7 +45,8 @@ const L = {
   divider: {
     use: "Section breaks. Always dark, keeps the tag, drops the footer. Prose goes in `body`",
     bleed: true,
-    fields: { eyebrow: str(), titleText: s("title", req()), body: str() },
+    fields: { eyebrow: str(), titleText: s("title", req()), body: str(),
+              part: str({ note: '"Part II" — set before the body as "Part II  ·  <body>"' }) },
   },
   closing: {
     use: "Last slide. Always dark, centred, full bleed",
@@ -54,7 +57,7 @@ const L = {
   /* ----------------------------------------------------- guideline (0.9) */
   agenda: {
     use: "What we'll cover — 2–5 numbered cards in a row",
-    fields: { items: s("object[]", req({ min: 2, max: 5, of: { title: str(req()), body: str() } })) },
+    fields: { items: s("object[]", req({ min: 2, max: 5, of: { title: str(req()), body: str(), meta: str({ note: '"15 min"' }) } })) },
   },
   team: {
     use: "Who's in the room — 2–4 people, each with a headshot slot the user fills",
@@ -70,7 +73,20 @@ const L = {
   },
   coDelivery: {
     use: "Up to six numbered rows in two columns — a co-delivery model, operating principles",
-    fields: { items: s("object[]", req({ min: 2, max: 6, of: { title: str(req()), body: str(req()) } })) },
+    fields: { items: s("object[]", req({ min: 2, max: 6, of: { title: str(req()), body: str(req()), meta: str({ note: '"15 min" — makes it the session agenda' }) } })) },
+  },
+  flowCompare: {
+    use: "Two lanes of steps — today vs with Wand. Mark the steps a person does `human: true`",
+    fields: { lanes: s("object[]", req({ min: 2, max: 2, of: {
+      label: str(req()), caption: str(),
+      steps: s("object[]", req({ min: 3, max: 5, of: { who: str(), step: str(req()), human: s("boolean") } })),
+    } })) },
+  },
+  timeline: {
+    use: "A journey in 2–4 phases on a line — months, a label, bullets",
+    fields: { phases: s("object[]", req({ min: 2, max: 4, of: {
+      when: str(), label: str(req()), bullets: s("string[]", { max: 6 }),
+    } })) },
   },
 
   /* --------------------------------------------------------------- content */
@@ -322,6 +338,7 @@ const TYPEOF = {
   "string[]": (v) => Array.isArray(v) && v.every((x) => typeof x === "string"),
   "object[]": (v) => Array.isArray(v) && v.every((x) => x && typeof x === "object" && !Array.isArray(x)),
   object: (v) => v && typeof v === "object" && !Array.isArray(v),
+  notes: (v) => typeof v === "string" || (v && typeof v === "object" && !Array.isArray(v)),
 };
 
 function checkFields(defs, value, path, errs, warns) {
@@ -395,6 +412,14 @@ function validate(spec) {
     seen.push(sl.layout);
   });
 
+  // backups live after the close — hidden, so they never interrupt the room
+  const closeAt = spec.slides.findIndex((x) => x.layout === "closing");
+  spec.slides.forEach((x, i) => {
+    if (x.backup && closeAt >= 0 && i < closeAt) warns.push(`S${i + 1} is a backup slide before the closing — move it after S${closeAt + 1}`);
+    if (x.notes && typeof x.notes === "object" && x.notes.time && !/\d\d:\d\d/.test(x.notes.time))
+      warns.push(`S${i + 1} notes.time "${x.notes.time}" is not a time window — use "00:21 to 00:25"`);
+  });
+
   // §5: vary the layouts, alternate the themes
   const distinct = new Set(seen).size;
   if (spec.slides.length >= 10 && distinct < 8) {

package/lib/trace.js

@@ -52,7 +52,7 @@ function fakePres() {
 function trace(W, spec) {
   const pres = fakePres();
   pres.layout = "LAYOUT_16x9";
-  const total = spec.slides.length;
+  const total = spec.slides.filter((x) => !x.backup).length;
   let n = 0;
   const errors = [];
 
@@ -63,12 +63,12 @@ function trace(W, spec) {
       return;
     }
     const fullBleed = ["cover", "divider", "closing"].includes(sl.layout);
-    n += 1;
-    const args = { ...sl, n, total };
+    const args = { ...sl, n: sl.backup ? null : ++n, total };
     if (!fullBleed) {
       args.deck = sl.deck || spec.deck;
       args.confidential = sl.confidential || spec.confidential;
     }
+    W.context({ confidential: args.confidential || "STRICTLY CONFIDENTIAL" });
     try { fn(pres, args); }
     catch (e) { errors.push(`slide ${i + 1} (${sl.layout}): ${e.message}`); }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wand-decks-kit",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Rebuilds or authors a client-ready .pptx on the Wand design system: measured fit, embedded Geist, verbatim content.",
   "license": "SEE LICENSE IN PROMPT.md",
   "bin": {

package/preview/preview.css

@@ -90,6 +90,8 @@ header input[type="range"] { width: 120px; accent-color: var(--accent); }
 
 .sh.rect      { border-radius: 0; }
 .sh.roundRect { border-radius: calc(var(--in) * .10); }
+/* flow connectors: pptxgenjs triangle rotated 90 points right */
+.sh.triangle  { clip-path: polygon(0 0, 100% 50%, 0 100%); }
 .sh.ellipse   { border-radius: 50%; }
 
 .sh.image { object-fit: contain; }

package/tools/brandlint.py

@@ -23,7 +23,9 @@ z = zipfile.ZipFile(deck)
 names = sorted((n for n in z.namelist() if re.fullmatch(r"ppt/slides/slide\d+\.xml", n)),
                key=lambda n: int(re.findall(r"\d+", n)[0]))
 pres = z.read("ppt/presentation.xml").decode()
-cx, cy = (int(v) for v in re.search(r'<p:sldSz cx="(\d+)" cy="(\d+)"', pres).groups())
+# attribute order varies by writer — the Kearney deck writes cy before cx
+tag = re.search(r"<p:sldSz[^>]*>", pres).group(0)
+cx, cy = (int(re.search(rf'{k}="(\d+)"', tag).group(1)) for k in ("cx", "cy"))
 canvas_ok = abs(cx / 914400 - 10) < 0.01 and abs(cy / 914400 - 5.625) < 0.01
 
 bad = 0

package/wand.js

@@ -10,11 +10,14 @@
  *   node wand.js doctor                      what works here, and what does not
  *   node wand.js rebuild source.pptx         phases 0-3: extract, then the worksheet
  *   node wand.js layouts [name]              the catalog, with every field
-  node wand.js glyphs  [search]            the named icon set
+ *   node wand.js glyphs  [search]            the named icon set
  *   node wand.js validate work/deck.json     fields and counts, before the build
  *   node wand.js preview  work/deck.json     browser preview at the 10in grid
  *   node wand.js ship     work/deck.json     build .pptx and .pdf, then every gate
-  node wand.js spec     deck.pptx          read back the spec a built deck carries
+ *   node wand.js show     deck.pptx [n]      one line per slide, or slide n's fields
+ *   node wand.js edit     deck.pptx --set 4.titleText="..."   patch a kit-built deck, rebuild, gate
+ *   node wand.js audit    any.pptx           every spec-free gate, incl. brand, on any deck
+ *   node wand.js spec     deck.pptx          read back the spec a built deck carries
  *
  * `rebuild` and `ship` are the two that matter. Everything else is a stage of
  * one of them, exposed so a failure can be re-run on its own.
@@ -254,6 +257,100 @@ function ship(specPath, outArg) {
   return gates.some(([, ok]) => ok === false) ? 1 : 0;
 }
 
+/* --------------------------------------------------------------- show/edit */
+
+/**
+ * Why these exist: a salesperson's edits are small — a date, a name, a title —
+ * and the old path cost two full copies of the spec in the context (read it,
+ * write it back) plus a rebuild. A 40 KB spec is ~10K tokens each way.
+ * `show` prints one line per slide, or one slide's fields; `edit` patches the
+ * spec the deck carries inside itself and ships. An edit costs a command line.
+ */
+function specOf(file) {
+  const f = path.resolve(file);
+  if (f.endsWith(".json")) return JSON.parse(fs.readFileSync(f, "utf8"));
+  const z = readZip(f);
+  if (!z.has("wand/spec.json")) die(`${rel(f)} carries no spec — it was not built by this kit.\n` +
+    "Edit it directly with the pptx tools, then run `node wand.js audit` on it (SKILL.md, \"Edit a deck they attached\").");
+  return JSON.parse(z.text("wand/spec.json"));
+}
+
+function oneLine(sl) {
+  // titleText arrays are runs of one line; titleLines are separate lines
+  const t = sl.titleText || sl.titleLines || sl.line1 || "";
+  const title = (Array.isArray(t) ? t.join(sl.titleLines && !sl.titleText ? " " : "") : String(t)).replace(/\s+/g, " ");
+  const bits = [sl.backup ? "BACKUP" : null, sl.notes ? "notes" : null, sl.dark === false ? "light" : null].filter(Boolean);
+  return `${sl.layout.padEnd(15)} ${title.slice(0, 64)}${bits.length ? "  [" + bits.join(", ") + "]" : ""}`;
+}
+
+function show(file, which) {
+  const spec = specOf(file);
+  if (which == null) {
+    console.log(`${spec.deck || "(untitled)"} — ${spec.slides.length} slides`);
+    spec.slides.forEach((sl, i) => console.log(`  ${String(i + 1).padStart(2)}  ${oneLine(sl)}`));
+    console.log("\nnode wand.js show <deck> <n>   for one slide's fields");
+    return 0;
+  }
+  const sl = spec.slides[Number(which) - 1];
+  if (!sl) die(`no slide ${which} — the deck has ${spec.slides.length}`);
+  console.log(JSON.stringify(sl, null, 1));
+  return 0;
+}
+
+/** "4.items.2.body" sets slide 4, item 2, body. 1-based, the way the room counts. */
+function setPath(spec, dotted, value) {
+  const [n, ...keys] = dotted.split(".");
+  let node = spec.slides[Number(n) - 1];
+  if (!node) die(`--set ${dotted}: no slide ${n}`);
+  if (!keys.length) die(`--set ${dotted}: name a field, e.g. ${n}.titleText`);
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = /^\d+$/.test(keys[i]) ? Number(keys[i]) - 1 : keys[i];
+    if (node[k] == null) node[k] = /^\d+$/.test(keys[i + 1]) ? [] : {};
+    node = node[k];
+  }
+  const last = keys[keys.length - 1];
+  node[/^\d+$/.test(last) ? Number(last) - 1 : last] = value;
+}
+
+/** Deck_v2.pptx -> Deck_v3.pptx; Deck.pptx -> Deck_v2.pptx. Never overwrite the input. */
+function nextVersion(file) {
+  const ext = path.extname(file), base = file.slice(0, -ext.length);
+  const m = /_v(\d+)$/.exec(base);
+  return m ? `${base.slice(0, m.index)}_v${Number(m[1]) + 1}${ext}` : `${base}_v2${ext}`;
+}
+
+function edit(file, args) {
+  const spec = specOf(file);
+  const changed = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--set") {
+      const arg = args[++i] || "", eq = arg.indexOf("=");
+      if (eq < 1) die(`--set wants N.path=value, got "${arg}"`);
+      const key = arg.slice(0, eq), raw = arg.slice(eq + 1);
+      let val; try { val = JSON.parse(raw); } catch { val = raw; }   // arrays, numbers, booleans parse; prose stays prose
+      setPath(spec, key, val); changed.push(`set ${key}`);
+    } else if (a === "--del") {
+      const n = Number(args[++i]); spec.slides.splice(n - 1, 1); changed.push(`deleted S${n}`);
+    } else if (a === "--move") {
+      const from = Number(args[++i]), to = Number(args[++i]);
+      const [sl] = spec.slides.splice(from - 1, 1); spec.slides.splice(to - 1, 0, sl); changed.push(`moved S${from} to ${to}`);
+    } else if (a === "--add") {
+      const at = Number(args[++i]); spec.slides.splice(at - 1, 0, JSON.parse(args[++i])); changed.push(`added S${at}`);
+    }
+  }
+  if (!changed.length) die("nothing to do — pass --set, --del, --move or --add");
+  console.log(changed.map((c) => "  " + c).join("\n"));
+  const work = path.join(path.dirname(path.resolve(file)), "work");
+  fs.mkdirSync(work, { recursive: true });
+  const specPath = path.join(work, "deck.json");
+  fs.writeFileSync(specPath, JSON.stringify(spec, null, 2));
+  if (args.includes("--dry")) { show(specPath); return validate(specPath) ? 1 : 0; }
+  const oi = args.indexOf("-o");
+  const out = oi >= 0 ? path.resolve(args[oi + 1]) : nextVersion(path.resolve(file));
+  return ship(specPath, out);
+}
+
 /**
  * Every gate that does not need a spec, on any .pptx.
  *
@@ -486,6 +583,16 @@ to.
     process.exit(0);
   }
 
+  case "show": {
+    if (!positional[0]) die("usage: node wand.js show <deck.pptx|deck.json> [slide]");
+    process.exit(show(positional[0], positional[1]));
+  }
+
+  case "edit": {
+    if (!positional[0]) die("usage: node wand.js edit <deck.pptx> --set N.path=value [--del N] [--move N M] [--add N '<json>'] [-o out.pptx] [--dry]");
+    process.exit(edit(positional[0], rest));
+  }
+
   case "inspect":
     if (!positional[0]) die("usage: node wand.js inspect <deck.pptx>");
     process.exit(inspect(path.resolve(positional[0])) ? 1 : 0);

package/wand_kit.js

@@ -32,6 +32,7 @@ const T = {
   accentDeep: "6C5CE7",   // accent text on light surfaces
   accentSoft: "9481FF",   // accent text on dark: eyebrows, links, pills (text 22)
   accentPale: "DCD6F5",   // quote marks, soft labels on dark (text 12)
+  accentLight:"AA9BFF",   // divider sublines — "Part I · Working question" (Kearney example)
 
   bgDark:      "240F48",  // flat dark ground — the guideline paints no art on interior slides
   inkDark:     "FFFFFF",  // titles (text 101)
@@ -119,16 +120,29 @@ function chrome(slide, { tag, dark = true }) {
   });
 }
 
+/**
+ * Per-slide context the builder sets before each layout runs. No layout passes
+ * `confidential` to footer() — thirty-odd call sites — so a spec's
+ * `confidential` never reached a single slide: every deck said "STRICTLY
+ * CONFIDENTIAL" whatever it asked for. The builder sets it here instead.
+ */
+const CTX = { confidential: "STRICTLY CONFIDENTIAL" };
+function context(c) { Object.assign(CTX, c); }
+
 /** Footer band. `n` and `total` are literal — never a field. */
-function footer(slide, { deck, n, total, dark = true, confidential = "STRICTLY CONFIDENTIAL" }) {
+function footer(slide, { deck, n, total, dark = true, confidential = CTX.confidential }) {
   const c = dark ? T.footerDark : T.footerLight;
   // guideline: a 0.34" band at y 5.29, 7pt, "WAND · CONFIDENTIAL" left, "03/13" right
-  slide.addText(`WAND  ·  ${deck.toUpperCase()}`, {
+  const left = /^WAND\b/i.test(deck) ? deck.toUpperCase() : `WAND  ·  ${deck.toUpperCase()}`;
+  slide.addText(left, {
     x: 0.42, y: 5.29, w: 4.58, h: 0.34, margin: 0, isTextBox: true,
     fontFace: F.reg, fontSize: 7, color: c, valign: "middle",
   });
   const pad = (v) => String(v).padStart(2, "0");
-  slide.addText(`${confidential}  ·  ${pad(n)}/${pad(total)}`, {
+  // A backup slide sits after the close and is hidden; it has no place in the
+  // count the room sees, so it says what it is instead of "32/31".
+  const tail = n == null ? "BACKUP" : `${pad(n)}/${pad(total)}`;
+  slide.addText(`${confidential}  ·  ${tail}`, {
     x: 5.23, y: 5.29, w: 4.38, h: 0.34, margin: 0, isTextBox: true,
     fontFace: F.reg, fontSize: 7, color: c, align: "right", valign: "middle",
   });
@@ -322,27 +336,34 @@ function cover(pres, { eyebrow, titleLines, body, kickerPlain, kickerBold, tag,
 }
 
 /** L2 divider — dark only, full bleed, tag kept, no footer. */
-function divider(pres, { tag, eyebrow, titleText, body }) {
+function divider(pres, { tag, eyebrow, titleText, body, part }) {
   const s = pres.addSlide();
   s.background = { color: T.bgDark };
-  s.addImage({ path: `${ASSETS}/bg-statement-dark.png`, x: 0, y: 0, w: 10, h: 5.625 });
+  // Measured from the Kearney example: its own section art, a big line low on
+  // the left, and one subline — "Part I  ·  Working question: …". A title that
+  // is itself the question (a full sentence) sits higher and smaller.
+  s.addImage({ path: `${ASSETS}/divider-art.png`, x: 0, y: 0, w: 10, h: 5.625 });
   chrome(s, { tag, dark: true });
+  const plain = Array.isArray(titleText) ? titleText.join("") : titleText;
+  const question = plain.length > 44;
+  const box = question ? { y: 1.55, h: 1.3, size: 28 } : { y: 2.12, h: 0.72, size: 33 };
+  const size = autoSize(plain, 8.25, box.h, { family: F.reg, fontSize: box.size, min: 22, lineSpacingMultiple: 1.08 });
   if (eyebrow) s.addText(eyebrow.toUpperCase(), {
-    x: 0.38, y: 1.77, w: 8.9, h: 0.24, margin: 0, isTextBox: true,
-    fontFace: F.med, fontSize: 12, color: T.accentSoft, valign: "middle",
+    x: 0.42, y: box.y - 0.34, w: 8.25, h: 0.24, margin: 0, isTextBox: true,
+    fontFace: F.med, fontSize: 10, color: T.accentSoft, valign: "middle",
   });
   const runs = Array.isArray(titleText)
-    ? titleText.map((t, i) => ({
-        text: t,
-        options: i === 1
-          ? { fontFace: F.semi, fontSize: 44, italic: true, color: T.accentSoft }
-          : { fontFace: F.semi, fontSize: 44, color: T.white },
-      }))
-    : [{ text: titleText, options: { fontFace: F.semi, fontSize: 44, color: T.white } }];
-  s.addText(runs, { x: 0.38, y: 2.09, w: 8.6, h: 0.77, margin: 0, isTextBox: true, valign: "top" });
-  if (body) s.addText(body, {
-    x: 0.38, y: 2.91, w: 5.81, h: 0.72, margin: 0, isTextBox: true,
-    fontFace: F.reg, fontSize: 12, color: T.bodyDark, valign: "top", lineSpacingMultiple: 1.25,
+    ? titleText.map((t, i) => ({ text: t, options: i === 1
+        ? { fontFace: F.reg, fontSize: size, italic: true, color: T.accentSoft }
+        : { fontFace: F.reg, fontSize: size, color: T.white } }))
+    : [{ text: titleText, options: { fontFace: F.reg, fontSize: size, color: T.white } }];
+  s.addText(runs, { x: 0.42, y: box.y, w: 8.25, h: box.h, margin: 0, isTextBox: true,
+                    valign: question ? "top" : "bottom", lineSpacingMultiple: 1.08 });
+  const sub = [part, body].filter(Boolean).join("  ·  ");
+  if (sub) s.addText(sub, {
+    x: 0.42, y: box.y + box.h + 0.1, w: 5.6, h: 0.55, margin: 0, isTextBox: true,
+    fontFace: F.reg, fontSize: autoSize(sub, 5.6, 0.55, { family: F.reg, fontSize: 10, min: 8, lineSpacingMultiple: 1.3 }),
+    color: T.accentLight, valign: "top", lineSpacingMultiple: 1.3,
   });
   return s;
 }
@@ -1043,8 +1064,8 @@ function agenda(pres, { tag, titleText, subtitleText, items, dark = true, deck,
   list.forEach((it, i) => {
     const cx = 0.42 + i * (w + gap);
     card(s, { x: cx, y: cy, w, h: ch, dark, variant: "solid" });
-    s.addText(String(i + 1).padStart(2, "0"), {
-      x: cx + 0.15, y: cy + 0.14, w: 1.0, h: 0.15, margin: 0, isTextBox: true,
+    s.addText(String(i + 1).padStart(2, "0") + (it.meta ? "   ·   " + it.meta : ""), {
+      x: cx + 0.15, y: cy + 0.14, w: w - 0.3, h: 0.15, margin: 0, isTextBox: true,
       fontFace: F.semi, fontSize: 8, color: T.accentSoft, valign: "middle",
     });
     s.addText(it.title, {
@@ -1172,23 +1193,134 @@ function coDelivery(pres, { tag, titleText, subtitleText, items, dark = true, de
       x: cx + 0.55, y: cy + 0.12, w: cw - 0.7, h: 0.19, margin: 0, isTextBox: true,
       fontFace: F.semi, fontSize: 10, color: th.ink, valign: "middle",
     });
-    s.addText(it.body, {
-      x: cx + 0.55, y: cy + 0.35, w: cw - 0.7, h: ch - 0.42, margin: 0, isTextBox: true,
-      fontFace: F.reg, fontSize: autoSize(it.body, cw - 0.7, ch - 0.42, { family: F.reg, fontSize: 8, min: 6.5, lineSpacingMultiple: 1.2 }),
-      color: th.body, valign: "top", lineSpacingMultiple: 1.2,
+    // `meta` is the run-of-show time, "15 min" — set apart in accent so the
+    // room can read the agenda as a clock (Kearney's session slide).
+    const bodyRuns = [{ text: it.body, options: { color: th.body } }];
+    if (it.meta) bodyRuns.push({ text: "  ·  " + it.meta, options: { color: T.accentSoft, bold: true } });
+    s.addText(bodyRuns, {
+      x: cx + 0.55, y: cy + 0.35, w: cw - 0.7, h: ch - 0.42, margin: 0, isTextBox: true, fontFace: F.reg,
+      fontSize: autoSize(it.body + (it.meta ? "  ·  " + it.meta : ""), cw - 0.7, ch - 0.42, { family: F.reg, fontSize: 8, min: 6.5, lineSpacingMultiple: 1.2 }),
+      valign: "top", lineSpacingMultiple: 1.2,
     });
   });
   if (deck) footer(s, { deck, n, total, dark });
   return s;
 }
 
+
+/**
+ * Two lanes of steps — "today" against "with Wand" (Kearney S08, Israir "The
+ * Ceiling"). The point is where the person sits: every step, or only the one
+ * that needs judgment. lanes: [{ label, caption, steps: [{ who, step, human }] }]
+ */
+function flowCompare(pres, { tag, titleText, subtitleText, lanes, dark = true, deck, n, total }) {
+  const s = pres.addSlide();
+  background(s, dark); chrome(s, { tag, dark });
+  const th = theme(dark);
+  title(s, titleText, { dark, y: 0.78, h: 0.5 });
+  if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.26, h: 0.3 });
+  const laneY = [1.74, 3.40];
+  lanes.slice(0, 2).forEach((lane, li) => {
+    const y = laneY[li];
+    s.addText(lane.label.toUpperCase(), {
+      x: 0.42, y, w: 3.2, h: 0.18, margin: 0, isTextBox: true,
+      fontFace: F.med, fontSize: 7.5, color: T.accentSoft, valign: "middle",
+    });
+    s.addShape("rect", { x: 0.42 + Math.min(3.2, lane.label.length * 0.062) + 0.12, y: y + 0.085, w: 9.17 - Math.min(3.2, lane.label.length * 0.062) - 0.12, h: 0.01,
+      fill: { color: dark ? T.cardStroke : T.divider }, line: { width: 0 } });
+    const steps = lane.steps.slice(0, 5), gap = 0.30;
+    const w = (9.17 - gap * (steps.length - 1)) / steps.length, cy = y + 0.30, ch = 0.73;
+    steps.forEach((st, i) => {
+      const cx = 0.42 + i * (w + gap);
+      // Kearney's reading: the machine steps are the filled ones, so the eye sees
+      // how much of the line the agents carry and where the person still sits.
+      if (st.human) card(s, { x: cx, y: cy, w, h: ch, dark, variant: "solid" });
+      else s.addShape("roundRect", { x: cx, y: cy, w, h: ch, rectRadius: radius(w, ch),
+        fill: { color: dark ? T.cardStroke : T.accent }, line: { color: T.accent, width: 1 } });
+      if (st.who) s.addText(st.who.toUpperCase(), {
+        x: cx + 0.14, y: cy + 0.1, w: w - 0.28, h: 0.16, margin: 0, isTextBox: true,
+        fontFace: F.med, fontSize: 6.5, color: st.human ? T.accentSoft : T.accentPale, valign: "middle",
+      });
+      s.addText(st.step, {
+        x: cx + 0.14, y: cy + 0.32, w: w - 0.28, h: 0.32, margin: 0, isTextBox: true,
+        fontFace: F.semi, fontSize: autoSize(st.step, w - 0.28, 0.32, { family: F.semi, fontSize: 11, min: 8 }),
+        color: st.human ? th.ink : T.white, valign: "middle",
+      });
+      if (i < steps.length - 1) s.addShape("triangle", {
+        x: cx + w + gap / 2 - 0.05, y: cy + ch / 2 - 0.07, w: 0.11, h: 0.14, rotate: 90,
+        fill: { color: T.accent }, line: { width: 0 },
+      });
+    });
+    if (lane.caption) s.addText(lane.caption, {
+      x: 0.42, y: cy + ch + 0.1, w: 9.17, h: 0.24, margin: 0, isTextBox: true,
+      fontFace: F.reg, fontSize: autoSize(lane.caption, 9.17, 0.24, { family: F.reg, fontSize: 8.5, min: 7 }),
+      italic: true, color: th.body, valign: "middle",
+    });
+  });
+  if (deck) footer(s, { deck, n, total, dark });
+  return s;
+}
+
+/**
+ * A journey in phases on a line — "The transformation timeline" (Kearney S16).
+ * phases: [{ when, label, bullets: [..] }], 2–4 of them.
+ */
+function timeline(pres, { tag, titleText, subtitleText, phases, dark = true, deck, n, total }) {
+  const s = pres.addSlide();
+  background(s, dark); chrome(s, { tag, dark });
+  const th = theme(dark);
+  title(s, titleText, { dark, y: 0.78, h: 0.5 });
+  if (subtitleText) subtitle(s, subtitleText, { dark, y: 1.30, h: 0.3 });
+  const list = phases.slice(0, 4), gap = list.length === 4 ? 0.34 : 0.62;
+  const w = (9.14 - gap * (list.length - 1)) / list.length, x0 = 0.44;
+  const ly = 2.30, d = 0.30;
+  s.addShape("rect", { x: x0 + d / 2, y: ly + d / 2 - 0.01, w: 9.14 - d, h: 0.02,
+    fill: { color: T.accent }, line: { width: 0 } });
+  list.forEach((ph, i) => {
+    const cx = x0 + i * (w + gap);
+    s.addShape("ellipse", { x: cx, y: ly, w: d, h: d,
+      fill: { color: dark ? T.bgDark : T.bgLight }, line: { color: T.accent, width: 2 } });
+    s.addShape("ellipse", { x: cx + 0.09, y: ly + 0.09, w: d - 0.18, h: d - 0.18,
+      fill: { color: T.accent }, line: { width: 0 } });
+    const cy = 2.86;
+    if (ph.when) s.addText(ph.when, {
+      x: cx, y: cy, w, h: 0.2, margin: 0, isTextBox: true,
+      fontFace: F.reg, fontSize: 8.5, color: dark ? T.mutedDark : T.mutedLight, valign: "middle",
+    });
+    s.addText(ph.label.toUpperCase(), {
+      x: cx, y: cy + 0.22, w, h: 0.22, margin: 0, isTextBox: true,
+      fontFace: F.semi, fontSize: 10, color: dark ? T.accentPale : T.accentDeep, valign: "middle",
+    });
+    const bullets = (ph.bullets || []).map((b) => "•  " + b).join("\n");
+    if (bullets) s.addText(bullets, {
+      x: cx, y: cy + 0.52, w, h: 1.62, margin: 0, isTextBox: true,
+      fontFace: F.reg, fontSize: autoSize(bullets, w, 1.62, { family: F.reg, fontSize: 8.5, min: 6.5, lineSpacingMultiple: 1.3 }),
+      color: th.body, valign: "top", lineSpacingMultiple: 1.3, paraSpaceAfter: 3,
+    });
+  });
+  if (deck) footer(s, { deck, n, total, dark });
+  return s;
+}
+
+/**
+ * Speaker notes, in the run-of-show convention the Kearney example uses:
+ * the time window first, "CORE" when the slide carries the argument, then what
+ * to say, then who in the room will push on it. A plain string passes through.
+ */
+function notesText(nt) {
+  if (!nt) return "";
+  if (typeof nt === "string") return nt;
+  return [nt.time, nt.core ? "CORE" : null, nt.text, nt.watch ? "Watch for: " + nt.watch : null]
+    .filter(Boolean).join("\n");
+}
+
 module.exports = {
-  VERSION: "0.9.0",
+  VERSION: "0.10.0",
   T, F, COLS, ASSETS, radius, theme, autoSize, measure: M,
   background, chrome, footer, title, subtitle, kicker, contentTop,
   card, iconTile, pill,
   cover, divider, closing,
-  agenda, team, fourCards, deliverColumns, coDelivery,
+  agenda, team, fourCards, deliverColumns, coDelivery, flowCompare, timeline, notesText, context,
   threeUp, fourUpIcon, sixUpIcon, rows, parity, statQuad, statGrid, band,
   colCards, featureStats, barRank, bridge, heroQuad, productMap,