wand-kit 0.0.0-stage → 0.2.0

package/brands/next/lib/ttf.py

@@ -0,0 +1,169 @@
+"""
+ttf.py — the ~1% of TrueType that embed_fonts.py needs, with no fontTools.
+
+Reads `head` and `OS/2` for the fields an EOT header carries, and rewrites the
+`name` table so a face reports the family we address it by. Weight in this
+system is carried by the family name — `Geist SemiBold` regular, not `Geist`
+bold — so retagging is not cosmetic: without it PowerPoint resolves four of the
+five families to the same face.
+
+Everything else in the font is copied through untouched.
+"""
+
+import struct
+
+_HEAD_CHECKSUM_ADJ = 8      # offset of checkSumAdjustment within `head`
+_MAGIC = 0xB1B0AFBA
+
+
+class TTFError(ValueError):
+    pass
+
+
+class TTF:
+    def __init__(self, data):
+        if len(data) < 12:
+            raise TTFError("not a font: too short")
+        tag = data[:4]
+        if tag not in (b"\x00\x01\x00\x00", b"true", b"ttcf", b"OTTO"):
+            raise TTFError(f"unrecognised sfnt tag {tag!r}")
+        if tag == b"ttcf":
+            raise TTFError("font collections (.ttc) are not supported — pass a single face")
+        self.data = data
+        self.sfnt = tag
+        (num,) = struct.unpack(">H", data[4:6])
+        self.tables = {}
+        for i in range(num):
+            off = 12 + i * 16
+            t, csum, o, ln = struct.unpack(">4sIII", data[off:off + 16])
+            self.tables[t] = (o, ln, csum)
+
+    # -- reading -----------------------------------------------------------
+
+    def table(self, tag):
+        if isinstance(tag, str):
+            tag = tag.encode()
+        if tag not in self.tables:
+            raise TTFError(f"font has no {tag.decode()} table")
+        o, ln, _ = self.tables[tag]
+        return self.data[o:o + ln]
+
+    @property
+    def check_sum_adjustment(self):
+        return struct.unpack(">I", self.table("head")[8:12])[0]
+
+    @property
+    def os2(self):
+        """The OS/2 fields the EOT header needs."""
+        t = self.table("OS/2")
+        version = struct.unpack(">H", t[0:2])[0]
+        d = {
+            "version": version,
+            "usWeightClass": struct.unpack(">H", t[4:6])[0],
+            "panose": t[32:42],
+            "ulUnicodeRange": struct.unpack(">IIII", t[42:58]),
+            "fsSelection": struct.unpack(">H", t[62:64])[0],
+            # the font's own embedding permission; the EOT header must not claim more
+            "fsType": struct.unpack(">H", t[8:10])[0],
+        }
+        # code page ranges only exist from version 1
+        d["ulCodePageRange"] = struct.unpack(">II", t[78:86]) if version >= 1 and len(t) >= 86 else (0, 0)
+        return d
+
+    def names(self):
+        """{nameID: string} for the Windows/Unicode records, best effort."""
+        t = self.table("name")
+        count, storage = struct.unpack(">HH", t[2:6])
+        out = {}
+        for i in range(count):
+            p = 6 + i * 12
+            plat, enc, lang, nid, ln, off = struct.unpack(">HHHHHH", t[p:p + 12])
+            raw = t[storage + off: storage + off + ln]
+            try:
+                s = raw.decode("utf-16-be") if plat == 3 or (plat == 0) else raw.decode("latin-1")
+            except UnicodeDecodeError:
+                continue
+            out.setdefault(nid, s)
+        return out
+
+    # -- writing -----------------------------------------------------------
+
+    def retagged(self, family, subfamily, full, postscript):
+        """Return new font bytes with name IDs 1/2/4/6 replaced."""
+        replace = {1: family, 2: subfamily, 4: full, 6: postscript}
+        name = _rebuild_name(self.table("name"), replace)
+        return _reassemble(self, {b"name": name})
+
+
+def _rebuild_name(t, replace):
+    count, storage = struct.unpack(">HH", t[2:6])
+    records, strings, cursor = [], bytearray(), 0
+
+    for i in range(count):
+        p = 6 + i * 12
+        plat, enc, lang, nid, ln, off = struct.unpack(">HHHHHH", t[p:p + 12])
+        if nid in replace:
+            s = replace[nid]
+            raw = s.encode("utf-16-be") if plat in (0, 3) else s.encode("latin-1", "replace")
+        else:
+            raw = t[storage + off: storage + off + ln]
+        records.append((plat, enc, lang, nid, len(raw), cursor))
+        strings += raw
+        cursor += len(raw)
+
+    # sort order is required by the spec: platform, encoding, language, name
+    records.sort(key=lambda r: (r[0], r[1], r[2], r[3]))
+    head = struct.pack(">HHH", 0, len(records), 6 + len(records) * 12)
+    body = b"".join(struct.pack(">HHHHHH", *r) for r in records)
+    return head + body + bytes(strings)
+
+
+def _checksum(b):
+    if len(b) % 4:
+        b = b + b"\0" * (4 - len(b) % 4)
+    return sum(struct.unpack(f">{len(b)//4}I", b)) & 0xFFFFFFFF
+
+
+def _reassemble(font, overrides):
+    """Rewrite the whole sfnt with some tables replaced, fixing every offset,
+    every table checksum and the head checkSumAdjustment."""
+    tags = sorted(font.tables)
+    parts = {}
+    for t in tags:
+        parts[t] = overrides.get(t, font.table(t))
+
+    # head's checkSumAdjustment must be zero while the file checksum is taken
+    head = bytearray(parts[b"head"])
+    head[_HEAD_CHECKSUM_ADJ:_HEAD_CHECKSUM_ADJ + 4] = b"\0\0\0\0"
+    parts[b"head"] = bytes(head)
+
+    n = len(tags)
+    # binary-search fields the spec wants present; readers ignore them but
+    # validators complain when they are wrong
+    entry_selector = max(n.bit_length() - 1, 0)
+    search_range = (1 << entry_selector) * 16
+    out = bytearray(struct.pack(">4sHHHH", font.sfnt, n, search_range,
+                                entry_selector, n * 16 - search_range))
+
+    offset = 12 + n * 16
+    directory, body = bytearray(), bytearray()
+    for t in tags:
+        d = parts[t]
+        directory += struct.pack(">4sIII", t, _checksum(d), offset, len(d))
+        body += d
+        pad = (-len(d)) % 4
+        body += b"\0" * pad
+        offset += len(d) + pad
+
+    out += directory + body
+    adj = (_MAGIC - _checksum(bytes(out))) & 0xFFFFFFFF
+
+    head_off = struct.unpack(">I", out[12 + tags.index(b"head") * 16 + 8:
+                                       12 + tags.index(b"head") * 16 + 12])[0]
+    out[head_off + _HEAD_CHECKSUM_ADJ: head_off + _HEAD_CHECKSUM_ADJ + 4] = struct.pack(">I", adj)
+    return bytes(out)
+
+
+def load(path):
+    with open(path, "rb") as f:
+        return TTF(f.read())

package/brands/next/lib/wandxml.py

@@ -0,0 +1,37 @@
+"""
+wandxml.py — XML parsing that works with nothing installed.
+
+The kit has to run wherever someone unzips it. `defusedxml` is the better
+parser and we use it when it's there, but requiring a pip install to get past
+Phase 0 means the engine is unusable in exactly the situation it was built for:
+a fresh container with a zip and a .pptx in it.
+
+The stdlib fallback is guarded against the one attack that matters for a parser
+pointed at an untrusted .pptx — entity expansion — by refusing any document with
+a DOCTYPE. Office files never have one.
+"""
+
+try:
+    from defusedxml import minidom as _md
+    HARDENED = True
+except ImportError:                                    # stdlib fallback
+    from xml.dom import minidom as _md
+    HARDENED = False
+
+
+class UnsafeXML(ValueError):
+    pass
+
+
+def parse(data):
+    """Parse .pptx part bytes (or str) into a minidom Document."""
+    probe = data[:8192]
+    if isinstance(probe, bytes):
+        probe = probe.decode("utf-8", "ignore")
+    if not HARDENED and ("<!DOCTYPE" in probe or "<!ENTITY" in probe):
+        raise UnsafeXML(
+            "document declares a DOCTYPE or ENTITY. Office parts never do. "
+            "Refusing to parse it with the stdlib parser — `pip install defusedxml` "
+            "if this file is genuinely trusted."
+        )
+    return _md.parseString(data)

package/brands/next/tokens.json

@@ -0,0 +1,174 @@
+{
+  "_": "Canonical brand values, measured from the website's CSS (wand-ai-staging.webflow.io, 2026-10-05). BRAND.md documents usage; the deck kit, the art generator and the gates all read this file, so a palette change happens here once. Derived values are the site's opacity tokens flattened onto the ground they sit on, so a .pptx carries solid colours a gate can check. `roles`, `faces`, `shape` and `art` were added for the studio kit (power-prompts/studio), which draws both brands from one component set; the decks-next kit reads only `swatch` and `derived`.",
+  "swatch": {
+    "violet100": "504666",
+    "violet200": "3A314E",
+    "violet300": "261D3D",
+    "gold100": "B79A5E",
+    "gold200": "917741",
+    "gold300": "786336",
+    "beige100": "F1EFEB",
+    "beige200": "EBE8E2",
+    "beige300": "D5CEC2",
+    "darkGrey": "2D2D2D",
+    "white": "FFFFFF"
+  },
+  "derived": {
+    "bodyLight": {
+      "hex": "686766",
+      "from": "darkGrey @ 70% on beige100 - the site's text-2"
+    },
+    "mutedLight": {
+      "hex": "7B7B79",
+      "from": "darkGrey @ 60% on beige100"
+    },
+    "footLight": {
+      "hex": "8F8E8C",
+      "from": "darkGrey @ 50% on beige100"
+    },
+    "bodyDark": {
+      "hex": "BEBBC5",
+      "from": "white @ 70% on violet300 - the site's is-o70-w"
+    },
+    "bodyDarkAlt": {
+      "hex": "C4C1CA",
+      "from": "white @ 70% on violet200, lists inside dark cards"
+    },
+    "footDark": {
+      "hex": "888394",
+      "from": "white @ 45% on violet300"
+    }
+  },
+  "name": "next",
+  "title": "Wand, the website's brand (FK Roman, Overused Grotesk)",
+  "roles": {
+    "light": {
+      "bg": "F1EFEB",
+      "paper": "EBE8E2",
+      "ink": "2D2D2D",
+      "text": "686766",
+      "soft": "7B7B79",
+      "muted": "8F8E8C",
+      "accent": "B79A5E",
+      "accentText": "917741",
+      "label": "917741",
+      "emph": "3A314E",
+      "emphInk": "FFFFFF",
+      "emphText": "BEBBC5",
+      "emphAccent": "B79A5E",
+      "stroke": "EBE8E2",
+      "rule": "D5CEC2",
+      "track": "D5CEC2",
+      "surface": "EBE8E2"
+    },
+    "dark": {
+      "bg": "261D3D",
+      "paper": "3A314E",
+      "ink": "FFFFFF",
+      "text": "BEBBC5",
+      "soft": "C4C1CA",
+      "muted": "888394",
+      "accent": "B79A5E",
+      "accentText": "B79A5E",
+      "label": "B79A5E",
+      "emph": "504666",
+      "emphInk": "FFFFFF",
+      "emphText": "C4C1CA",
+      "emphAccent": "B79A5E",
+      "stroke": "3A314E",
+      "rule": "504666",
+      "track": "504666",
+      "surface": "3A314E"
+    }
+  },
+  "faces": {
+    "display": {
+      "family": "FK Roman Standard Light",
+      "weight": 300,
+      "tracking": -0.07,
+      "leading": 1.06
+    },
+    "body": {
+      "family": "Overused Grotesk",
+      "weight": 400,
+      "tracking": -0.02,
+      "leading": 1.5
+    },
+    "label": {
+      "family": "FK Roman Standard Light",
+      "weight": 300,
+      "tracking": 0.08,
+      "leading": 1.2,
+      "caps": true
+    },
+    "files": [
+      {
+        "family": "FK Roman Standard Light",
+        "weight": 300,
+        "italic": false,
+        "file": "FKRomanStandard-Light.ttf",
+        "pptx": "FK Roman Standard Light"
+      },
+      {
+        "family": "Overused Grotesk",
+        "weight": 400,
+        "italic": false,
+        "file": "OverusedGrotesk-Roman.ttf",
+        "pptx": "Overused Grotesk"
+      },
+      {
+        "family": "Overused Grotesk",
+        "weight": 400,
+        "italic": true,
+        "file": "OverusedGrotesk-Italic.ttf",
+        "pptx": "Overused Grotesk"
+      },
+      {
+        "family": "Overused Grotesk",
+        "weight": 500,
+        "italic": false,
+        "file": "OverusedGrotesk-Medium.ttf",
+        "pptx": "Overused Grotesk Medium"
+      },
+      {
+        "family": "Overused Grotesk",
+        "weight": 500,
+        "italic": true,
+        "file": "OverusedGrotesk-MediumItalic.ttf",
+        "pptx": "Overused Grotesk Medium"
+      },
+      {
+        "family": "Overused Grotesk",
+        "weight": 600,
+        "italic": false,
+        "file": "OverusedGrotesk-SemiBold.ttf",
+        "pptx": "Overused Grotesk SemiBold"
+      },
+      {
+        "family": "Overused Grotesk",
+        "weight": 600,
+        "italic": true,
+        "file": "OverusedGrotesk-SemiBoldItalic.ttf",
+        "pptx": "Overused Grotesk SemiBold"
+      }
+    ],
+    "license": "FK Roman Standard: commercial, the website's webfont converted for testing (see fonts/LICENSE-FONTS.md). Overused Grotesk: SIL OFL 1.1"
+  },
+  "shape": {
+    "radius": 0,
+    "cardStroke": 0,
+    "emphStroke": 0
+  },
+  "art": {
+    "cover": "cover-art.png",
+    "overlay": "cover-art.png",
+    "statement": "statement-art.png",
+    "closing": "closing-art.png",
+    "coverArt": "cover-art.png",
+    "divider": "divider-art.png",
+    "markOnLight": "spark-gold.png",
+    "markOnDark": "spark-gold.png",
+    "wordmarkOnLight": "wordmark-dark.png",
+    "wordmarkOnDark": "wordmark-light.png"
+  }
+}

package/examples/gallery/job.mjs

@@ -0,0 +1,83 @@
+/**
+ * The gallery — every component, light and dark, on the Letter surface, in
+ * the brand named by WAND_GALLERY_BRAND (node wand.js gallery --brand next).
+ * It is the regression for the component library: a change to components.js
+ * or to a brand's tokens is reviewed here once, on one sheet, before any job.
+ */
+import { DEFAULT_BRAND } from "../../lib/brand.js";
+
+const brand = process.env.WAND_GALLERY_BRAND || DEFAULT_BRAND;
+
+export default {
+  name: `Gallery ${brand}`,
+  file: `gallery-${brand}`,
+  brand,
+  surface: process.env.WAND_GALLERY_SURFACE || "letter",
+  tag: "Wand studio",
+  footer: `Component gallery · ${brand} brand`,
+  css: ``,
+  pages: (c) => {
+    const PHASES = ["Foundation", "Beachhead", "Controlled expansion", "Enterprise scale"];
+    const body = (dark) => `
+      ${c.sec("01", `Type and <em>sections</em>`)}
+      ${c.lead("The standfirst: one sentence that carries the page's claim, set larger than the body.")}
+      ${c.body("Running text at the surface's body size: a measure near 75 characters, ragged right, nothing under the minimum size, hierarchy from the face and the scale rather than from bold.")}
+      ${c.sec("02", `Cards and <em>grids</em>`)}
+      ${c.cols(3, [
+        c.card({ tag: "Layer 01", title: "Real agents", body: ["Persistent identity, layered memory, objectives and a full action history."] }),
+        c.card({ tag: "Layer 02", title: "An agentic workforce", body: ["Hired, onboarded, reviewed and retired like people, in one registry."] }),
+        c.card({ tag: "Layer 03", title: "Wand OS", emph: true, body: ["The control plane: policy, identity, audit and approval."] }),
+      ])}
+      ${c.cols(3, [
+        c.card({ cls: "fn", title: "Customer service", level: "h5", body: ["Changes, refunds, baggage and disruption cases resolved end to end."], out: "Serve growth without proportional hiring" }),
+        c.card({ cls: "fn", title: "Maintenance", level: "h5", body: ["Manuals, ADs and service bulletins turned into work-card packages."], out: "Absorb a new fleet type" }),
+        c.card({ cls: "fn", title: "Revenue accounting", level: "h5", body: ["Ticket sales, BSP, card settlements and refunds matched; leakage flagged."], out: "Protect margins as revenue scales" }),
+      ])}
+      ${c.stats([{ v: "$1.68T", k: "assets under management", hero: true }, { v: "150+", k: "countries served" }, { v: "+43.2%", k: "12-month total return" }])}
+      ${c.sec("03", `Chips, phases and <em>flows</em>`)}
+      ${c.strip(PHASES, { on: 1 })}
+      ${c.phase(0, PHASES[0], "One registry, one identity")}
+      ${c.flow({ label: "With Wand · AI as labor", nodes: [["Agent", "Notices", "a"], ["Agent", "Plans", "a"], ["Agent", "Executes", "a"], ["Agent", "Grades", "a"], ["Human", "Approves", "p"]],
+        note: "<b>Capacity = people + agents.</b> The person moves from every step to the one that needs judgment." })}
+      ${c.cols(2, [c.list(["One registry for people and agents", "Objectives, KPIs and reviews"]), `<div class="card sm">${c.tile("shield-check")}${c.h5("Governance")}<p>A glyph on a tile, recoloured through the theme.</p></div>`], { stretch: false })}
+    `;
+    const body2 = (dark) => `
+      ${c.sec("04", `Tables and <em>figures</em>`)}
+      ${c.table({ head: ["Phase", "Foundation", "First deploy", "Expansion", "Scaling"], emph: 0, rows: [
+        ["Agentic GDP", { v: "0%", meter: true }, { v: "8%", meter: true }, { v: "20%", meter: true }, { v: "40%", meter: true }],
+        ["Process penetration", { v: "0%", meter: true }, { v: "5%", meter: true }, { v: "18%", meter: true }, { v: "55%", meter: true }],
+      ] })}
+      ${c.table({ head: ["Total return", "BEN", "BLK", "Edge: BEN"], cls: "price", rows: [
+        ["Trailing 12 months", { v: "+43.2%", cls: "strong" }, "+7.2%", { v: "+36 pts", cls: "accent" }],
+        ["Closing price", { v: "$31.21", cls: "strong" }, "$1,046.49", { v: "n/a", cls: "accent" }],
+      ] })}
+      ${c.cols(3, [
+        c.card({ cls: "proof", tag: "Global asset manager", title: "RFP response", level: "h5", body: `${c.delta("120 hrs", "10 hrs")}<p>More volume with a smaller team.</p>` }),
+        c.card({ cls: "proof", tag: "Global law firm", title: "Contract review", level: "h5", body: `${c.delta("2–3 hrs", "15 min")}<p>Nine times the volume, same team.</p>` }),
+        c.card({ cls: "proof", tag: "Government agency", title: "Visa adjudication", level: "h5", body: `${c.delta("4–6 hrs", "50 min")}<p>500,000 staff hours a year released.</p>` }),
+      ])}
+      ${c.note(`<b>Small print.</b> Sources, footnotes and the distribution line are set in the soft colour at the note size.`)}
+      ${c.sec("05", `Quotes, callouts and <em>steps</em>`)}
+      ${c.cols(2, [
+        c.quote({ text: "Wand helps us move beyond isolated AI tools into a connected agentic workforce, a new operating model for scaling intelligence across the organization.", by: ["Jenny Johnson", "CEO, Franklin Templeton"] }),
+        c.quote({ text: "With strong governance in place, we are demonstrating that AI can deliver secure, scalable, and measurable value.", by: ["Vasundhara Chetluru", "Head of AI Platform, Franklin Templeton"], emph: true }),
+      ])}
+      ${c.callout({ tag: "Why identity-first matters in asset management", text: "Treating agents as governed identities, not anonymous scripts, is what lets a regulated firm scale AI safely." })}
+      ${c.steps([
+        { title: "Working session", when: "Within 3 weeks", body: "Two hours with the functions that own the shortlist." },
+        { title: "Deployment posture", when: "Weeks 3–5", body: "Environment, policies and approval gates agreed." },
+        { title: "First agents live", when: "Within 90 days", body: "Real work on real data, measured against the baseline.", emph: true },
+      ])}
+    `;
+    return [
+      c.cover({ label: "Wand studio", title: `The component <em>gallery</em>`, lede: `Every component on the ${brand} brand, light and dark, on one surface.`,
+        body: "Review this sheet after any change to components.js or a brand's tokens. What reads wrong here reads wrong in every job.",
+        meta: `${brand} brand · ${process.env.WAND_GALLERY_SURFACE || "letter"} surface` }),
+      c.page({ eyebrow: "Light ground", body: body(false) }),
+      c.page({ eyebrow: "Light ground", body: body2(false) }),
+      c.page({ eyebrow: "Dark ground", dark: true, body: body(true) }),
+      c.page({ eyebrow: "Dark ground", dark: true, body: body2(true) }),
+      c.closing({ pair: "Wand studio", title: "The component gallery", lede: "A closing page: the lockup over the closing art." }),
+    ];
+  },
+};

package/examples/overview/job.mjs

@@ -0,0 +1,99 @@
+/**
+ * The Agentic Workforce for Aviation: a cover and two pages, US Letter, on the
+ * current brand. Authored copy (no content file), so coverage is skipped and
+ * the review reads the argument instead. The regression for the page surface:
+ * three sections a page, the chip strip, the five-node flow, cards in threes
+ * and fours, next-step cards with arrows.
+ */
+const FUNCTIONS = [
+  ["Customer service", "Changes, refunds, baggage and disruption cases resolved end to end, in every language.", "Serve growth without proportional hiring"],
+  ["Reservations & ticketing", "Reprotection, name corrections, group bookings, PNR cleanup, reissues and exchanges.", "More volume per employee"],
+  ["Dynamic pricing", "Competitor fares and demand watched continuously; fare updates prepared and loaded.", "Maximise yield on every route"],
+  ["Flight ops support", "Briefing packs, crew currency and duty limits, and turnaround milestones tracked.", "Grow the network, not the ops headcount"],
+  ["Maintenance", "Manuals, ADs and service bulletins turned into work-card packages; records kept audit-ready.", "Absorb a new fleet type"],
+  ["Revenue accounting", "Ticket sales, BSP, card settlements and refunds matched; leakage flagged.", "Protect margins as revenue scales"],
+  ["Finance operations", "Supplier, lessor and fuel invoices processed and reconciled against contract and uplift data.", "A lean finance function"],
+  ["Marketing", "Route-launch campaigns built, launched and monitored across segments and channels.", "Fill seats on every new route"],
+  ["Software development", "AI dev pods ship booking-site features and keep the integration stack patched.", "Ship at challenger speed"],
+];
+
+export default {
+  name: "The Agentic Workforce for Aviation",
+  file: "Wand_Agentic_Workforce_for_Aviation",
+  brand: process.env.WAND_BRAND || "current",
+  surface: "letter",
+  tag: "The Agentic Workforce",
+  footer: "Wand AI · Strictly confidential, prepared for airline leadership",
+  denylist: ["Israir", "Sirkis"],
+  css: `
+.cover .top{margin-top:4%}
+.models{display:flex;flex-direction:column;gap:1em}
+.models .pair{display:flex;align-items:stretch;gap:.9em}
+.models .pair .arrow{align-self:center;width:calc(var(--m-arrow) * 1.25);height:calc(var(--m-arrow) * 1.25);fill:var(--accent)}
+.models .card{flex:1}
+.models .card.emph{background:var(--emph)}
+.kpis{row-gap:calc(var(--m-col-gap) * .9)}
+.kpi{display:flex;gap:.8em;align-items:flex-start;padding-top:.7em;border-top:1px solid var(--rule)}
+.kpi .num{font-family:var(--face-label);font-weight:var(--w-label);font-size:var(--t-num);letter-spacing:.2em;color:var(--label);padding-top:.25em}
+.kpi h5{margin-bottom:.25em}
+.kpi p{font-size:var(--t-sm);line-height:1.5;color:var(--text)}
+`,
+  pages: (c) => [
+    c.cover({
+      label: "Wand × Aviation",
+      title: `The Agentic Workforce<br>for <em>Aviation</em>`,
+      lede: "Airlines are adding aircraft, routes and long-haul flying at record pace. The back office is the same size.",
+      body: "Contact centre, reservations, operations and finance are still sized for the airline of a few years ago. Without another kind of worker, a carrier either hires into its margin or lets service crack exactly when the market is watching.",
+      extra: `<div class="models">${c.tag("Two models")}<div class="pair">
+        ${c.card({ tag: "Today · every airline", title: "Human-centric", body: `<div class="sub">100% human</div><p>Humans think, decide and execute. AI shows up in pockets, as tools. Sophisticated, but slow, costly and capped.</p>` })}
+        ${c.arrow}
+        ${c.card({ tag: "The target model", title: "Dual workforce", emph: true, body: `<div class="sub">Humans + AI agents</div><p>One workforce, two kinds of colleagues. Agent workers carry the volume growth, so the team that built the airline stays lean and fast.</p>` })}
+      </div>${c.p("Overview for airline leadership  ·  October 2026  ·  Strictly confidential", "meta")}</div>`,
+    }),
+
+    c.page({ eyebrow: "The platform", body: `
+      ${c.sec("01", `The <em>Ceiling</em>`)}
+      ${c.body("Copilots make tasks faster. AI labor does the work itself. That is the difference between an efficiency programme and a capacity programme.")}
+      ${c.flow({ label: "Today · AI as a tool", nodes: [["Person", "Notices", "p"], ["Person", "Gathers", "p"], ["Person", "Instructs", "p"], ["AI", "Drafts", "a"], ["Person", "Checks", "p"]],
+        note: "<b>Capacity = your people.</b> Four of five steps wait on a person; that person is the ceiling." })}
+      ${c.flow({ label: "With Wand · AI as labor", nodes: [["Agent", "Notices", "a"], ["Agent", "Plans", "a"], ["Agent", "Executes", "a"], ["Agent", "Grades", "a"], ["Human", "Approves", "p"]],
+        note: "<b>Capacity = people + agents.</b> The person moves from every step to the one that needs judgment." })}
+      ${c.sec("02", `Three <em>Layers</em>`)}
+      ${c.body("Model-agnostic and cloud-agnostic: Wand runs inside the airline's own environment, on its own models, behind its own controls.")}
+      ${c.cols(3, [
+        c.card({ tag: "Layer 01", title: "Real agents", body: ["Persistent identity, memory, objectives and full action history. They do not wait for a prompt; they notice, plan, act and grade their own work."] }),
+        c.card({ tag: "Layer 02", title: "An agentic workforce", body: ["Agents are hired, onboarded, reviewed and retired like people, in one registry that holds humans and agents together."] }),
+        c.card({ tag: "Layer 03", title: "Wand OS", emph: true, body: ["The control plane the workforce reports into: policy, identity, audit and approval, integrated with booking, ops, maintenance and finance."] }),
+      ])}
+      ${c.sec("03", `Four <em>Controls</em>`)}
+      ${c.body("In aviation, governance is the deployment prerequisite, which is why we built it first.")}
+      ${c.cols(4, [
+        c.card({ tag: "01", title: "Policy", level: "h5", body: ["Rules the platform enforces, not guidance a model is asked to follow."] }),
+        c.card({ tag: "02", title: "Identity", level: "h5", body: ["Every agent has its own identity and permissions. No shared accounts."] }),
+        c.card({ tag: "03", title: "Audit", level: "h5", body: ["Every action written to an immutable record an auditor can replay."] }),
+        c.card({ tag: "04", title: "Human approval", level: "h5", body: ["Named people approve at the gates you set, per process."] }),
+      ])}
+      ${c.note("Built for civil aviation authorities, FAA, DOT and TSA, EASA and EU obligations: every agent action is attributable, bounded and reconstructable.")}
+    ` }),
+
+    c.page({ eyebrow: "In the airline", body: `
+      ${c.sec("04", `Where This <em>Lands</em>`)}
+      ${c.cols(3, FUNCTIONS.map(([t, b, o]) => c.card({ cls: "fn", title: t, level: "h5", body: [b], out: o })))}
+      ${c.sec("05", `Measured <em>against a baseline</em>`)}
+      ${c.cols(3, [
+        ["01", "Volume per FTE", "Cases handled per person per day, before and after. The capacity number."],
+        ["02", "Cycle time", "End-to-end elapsed time per case, including the escalations."],
+        ["03", "Error rate against review", "How often a human reviewer disagrees with the agent. The quality gate that matters most."],
+        ["04", "Escalation rate", "Share of cases routed to a person. Falls as the agent learns; never reaches zero by design."],
+        ["05", "Cost per transaction", "Fully loaded, agent and human combined. The number that shows up in the operating line."],
+        ["06", "Time to production", "Weeks from kickoff to the first agent doing real work on real data."],
+      ].map(([n, t, b]) => `<div class="kpi"><span class="num">${n}</span><div>${c.h5(t)}<p>${b}</p></div></div>`), { cls: "kpis" })}
+      ${c.sec("06", `Three <em>Steps</em>`)}
+      ${c.steps([
+        { title: "Working session", when: "Within 3 weeks", body: "Two hours with the functions that own the shortlist. One process chosen, its baseline written down." },
+        { title: "Deployment posture", when: "Weeks 3–5", body: "Environment, policies and approval gates agreed with your technology and compliance teams." },
+        { title: "First agents live", when: "Within 90 days", body: "Real work on real data, inside your environment, measured against the baseline.", emph: true },
+      ])}
+    ` }),
+  ],
+};