#!/usr/bin/env python3
"""Generate the SnapKitty Cosmic Field Manifesto booklet (15 pages) as a PDF.

Style: research-notebook x terminal-UI x cosmic field-manual.
Black-space backgrounds, glowing OMEGA constellations, terminal windows over
nebula art, ASCII diagrams, experiment-log telemetry, WORM-chain celestial
nodes, orbital gate diagrams, glitch-art dividers, agent sigil profiles, and
large pull quotes.

Assets used:
  - nft_collection/nft_out/glitch_00..08.svg  (rasterized here)
  - paper/mathlib5/simple/cover.png            (full-bleed cover / closing)
"""
import os, re, math, random
from PIL import Image, ImageDraw, ImageFont, ImageFilter

ROOT = r"C:\Users\jessi\SNAPKITTYWEST"
GLITCH_DIR = os.path.join(ROOT, "nft_collection", "nft_out")
COVER = os.path.join(ROOT, "paper", "mathlib5", "simple", "cover.png")
OUT = os.path.join(ROOT, "docs", "booklet", "SnapKitty_Cosmic_Manifesto.pdf")

W, H = 1240, 1754  # A4 ~ portrait at 150 dpi

# ---- palette ----
BG      = (5, 1, 10)
BG2     = (10, 4, 20)
CYAN    = (60, 220, 255)
MAGENTA = (255, 56, 214)
GREEN   = (70, 255, 120)
PURPLE  = (160, 110, 255)
GOLD    = (255, 210, 90)
WHITE   = (235, 240, 255)
DIM     = (120, 130, 160)

random.seed(777)

# ---- fonts ----
def F(size, bold=False):
    names = ["consolab.ttf", "courbd.ttf", "consola.ttf", "cour.ttf", "lucon.ttf"]
    base = r"C:\Windows\Fonts"
    for n in names:
        p = os.path.join(base, n)
        if os.path.exists(p):
            try:
                return ImageFont.truetype(p, size)
            except Exception:
                pass
    return ImageFont.load_default()

def font_path(bold=False):
    names = (["consolab.ttf", "courbd.ttf"] if bold else ["consola.ttf", "cour.ttf"])
    for n in names:
        p = os.path.join(r"C:\Windows\Fonts", n)
        if os.path.exists(p):
            return p
    return None

# ---- glitch rasterization ----
def rasterize_glitch(svg_path, size=W):
    img = Image.new("RGB", (size, size), BG)
    px = img.load()
    txt = open(svg_path, encoding="utf-8").read()
    # background
    m = re.search(r'<rect width="100%" height="100%" fill="(#\w+)"', txt)
    if m:
        img = Image.new("RGB", (size, size), tuple(int(m.group(1)[i:i+2], 16) for i in (1, 3, 5)))
    scale = size / 1024.0
    # collect colored rects (screen blend => additive)
    rects = re.findall(r'<rect x="(\d+)" y="(\d+)" width="(\d+)" height="(\d+)" fill="rgb\(([\d,]+)\)" opacity="([\d.]+)"', txt)
    for x, y, w, h, rgb, op in rects:
        x, y, w, h = int(float(x)*scale), int(float(y)*scale), max(1, int(float(w)*scale)), max(1, int(float(h)*scale))
        r, g, b = (int(v) for v in rgb.split(","))
        a = float(op)
        for yy in range(y, min(y+h, size)):
            for xx in range(x, min(x+w, size)):
                pr, pg, pb = px[xx, yy]
                px[xx, yy] = (
                    min(255, int(pr + r*a)),
                    min(255, int(pg + g*a)),
                    min(255, int(pb + b*a)),
                )
    # scanlines
    for yy in range(0, size, 4):
        for xx in range(size):
            pr, pg, pb = px[xx, yy]
            px[xx, yy] = (int(pr*0.82), int(pg*0.82), int(pb*0.82))
    # text labels
    labels = re.findall(r'<text x="(\d+)" y="(\d+)"[^>]*fill="(#\w+)"[^>]*>([^<]+)</text>', txt)
    d = ImageDraw.Draw(img)
    for x, y, col, s in labels:
        c = tuple(int(col[i:i+2], 16) for i in (1, 3, 5))
        d.text((float(x)*scale, float(y)*scale), s, font=F(28), fill=c)
    return img

# ---- helpers ----
def new_page(bg=BG):
    return Image.new("RGB", (W, H), bg)

def starfield(img, n=140, maxr=1.6):
    d = ImageDraw.Draw(img)
    for _ in range(n):
        x = random.randint(0, W); y = random.randint(0, H)
        r = random.uniform(0.4, maxr)
        b = random.randint(120, 255)
        tint = random.choice([(b, b, b), (int(b*0.7), int(b*0.85), b), (b, int(b*0.8), int(b*0.9))])
        d.ellipse([x-r, y-r, x+r, y+r], fill=tint)
    return img

def glow_layer(draw_fn, blur=18, size=(W, H)):
    """Return a blurred RGBA copy of content drawn by draw_fn on transparent layer."""
    layer = Image.new("RGBA", size, (0, 0, 0, 0))
    draw_fn(ImageDraw.Draw(layer))
    glow = layer.filter(ImageFilter.GaussianBlur(blur))
    return glow

def add_glow(img, draw_fn, blur=16, alpha=0.9):
    """Composite a glow (screen-blended) plus sharp content onto img."""
    sharp = Image.new("RGBA", (W, H), (0, 0, 0, 0))
    draw_fn(ImageDraw.Draw(sharp))
    glow = sharp.filter(ImageFilter.GaussianBlur(blur))
    img.paste(Image.blend(img.convert("RGBA"), Image.alpha_composite(img.convert("RGBA"), glow), alpha), (0, 0))
    img.paste(Image.alpha_composite(img.convert("RGBA"), sharp), (0, 0))
    return img

def text(img, xy, s, font, fill, glow=None, align="left"):
    d = ImageDraw.Draw(img)
    if align == "center":
        l, t, r, b = d.textbbox((0, 0), s, font=font)
        xy = (xy[0] - (r-l)/2, xy[1])
    if glow:
        col = glow
        add_glow(img, lambda dd: dd.text(xy, s, font=font, fill=col), blur=14, alpha=0.8)
    d.text(xy, s, font=font, fill=fill)
    return img

def rounded_rect(d, box, r, fill=None, outline=None, width=2):
    d.rounded_rectangle(box, radius=r, fill=fill, outline=outline, width=width)

def terminal(img, box, title, lines, accent=CYAN, titlebar=True):
    d = ImageDraw.Draw(img)
    x0, y0, x1, y1 = box
    # outer glow
    add_glow(img, lambda dd: dd.rounded_rectangle(box, radius=18, outline=accent, width=3), blur=20, alpha=0.7)
    # body
    d.rounded_rectangle(box, radius=18, fill=(8, 12, 18))
    d.rounded_rectangle([x0, y0, x1, y0+44], radius=18, fill=(14, 20, 30))
    if titlebar:
        for i, c in enumerate([(255, 95, 86), (255, 189, 68), (70, 255, 120)]):
            d.ellipse([x0+22+i*26, y0+16, x0+34+i*26, y0+28], fill=c)
        text(img, (x0+118, y0+14), title, F(22), DIM)
    ty = y0 + (64 if titlebar else 24)
    lh = 30
    for ln in lines:
        col = ln[1] if isinstance(ln, tuple) else WHITE
        s = ln[0] if isinstance(ln, tuple) else ln
        d.text((x0+24, ty), s, font=F(19), fill=col)
        ty += lh
    return img

def glitch_bg(img, idx, alpha=0.5):
    g = GLITCH.get(int(idx) % 9, _art("art_constellation")).resize((W, H))
    return Image.blend(img, g, alpha)

# preload new cosmic art raster (docs/booklet/art/*.png)
ARTDIR = os.path.join(ROOT, "docs", "booklet", "art")
def _art(name):
    return Image.open(os.path.join(ARTDIR, name + ".png")).convert("RGB").resize((W, H))
# index map for glitch_bg(idx) calls in page builders
GLITCH = {
    0: _art("art_cover"), 2: _art("art_echo"), 3: _art("art_sieve"),
    4: _art("art_echo"), 5: _art("art_gates"), 7: _art("art_quantum"),
    8: _art("art_closing"),
}
COVER_IMG = _art("art_cover")

# ---- page builders ----
pages = []

def page_divider(num, label, accent=MAGENTA):
    img = new_page()
    starfield(img, 90)
    add_glow(img, lambda d: d.line([(120, H//2), (W-120, H//2)], fill=accent, width=2), blur=16, alpha=0.8)
    # glitch ticks
    d = ImageDraw.Draw(img)
    for i in range(40):
        x = random.randint(120, W-120)
        y = H//2 + random.randint(-3, 3)
        d.rectangle([x, y, x+random.randint(8, 40), y+2], fill=random.choice([CYAN, MAGENTA, GREEN, PURPLE]))
    text(img, (W//2, H//2-130), "✦ ❖ ✦", F(40), accent, glow=accent, align="center")
    text(img, (W//2, H//2-60), label, F(46, bold=True), WHITE, glow=accent, align="center")
    text(img, (W//2, H//2+120), f"CHAPTER {num:02d}", F(26), DIM, align="center")
    return img

# 1. COVER
def p_cover():
    img = COVER_IMG.copy()
    img = Image.blend(img, Image.new("RGB", (W, H), BG), 0.18)
    img = glitch_bg(img, 0, 0.18)
    # vignette
    vig = Image.new("L", (W, H), 0)
    vd = ImageDraw.Draw(vig)
    vd.ellipse([-300, -300, W+300, H+300], fill=255)
    vig = vig.filter(ImageFilter.GaussianBlur(200))
    dark = Image.new("RGB", (W, H), BG)
    img = Image.composite(img, dark, vig)
    add_glow(img, lambda d: d.text((W//2, 360), "Ω", font=F(150), fill=CYAN), blur=40, alpha=1.0)
    text(img, (W//2, 560), "SNAPKITTY", F(78, bold=True), WHITE, glow=CYAN, align="center")
    text(img, (W//2, 650), "SOVEREIGN COMPUTE", F(54, bold=True), CYAN, glow=CYAN, align="center")
    text(img, (W//2, 760), "A COSMIC FIELD MANIFESTO", F(30), MAGENTA, glow=MAGENTA, align="center")
    # rule
    add_glow(img, lambda d: d.line([(320, 880), (W-320, 880)], fill=PURPLE, width=2), blur=14, alpha=0.8)
    text(img, (W//2, 930), "Evidence or Silence.", F(34, bold=True), GREEN, glow=GREEN, align="center")
    text(img, (W//2, 1500), "Ahmad Ali Parr · SnapKitty Collective", F(26), DIM, align="center")
    text(img, (W//2, 1550), "Zenodo 10.5281/zenodo.21132094", F(22), DIM, align="center")
    text(img, (W//2, 1600), "ORCID 0009-0006-1916-5245", F(22), DIM, align="center")
    return img

# 2. MISSION / PULL QUOTE
def p_mission():
    img = new_page(); starfield(img, 160)
    # omega constellation
    pts = [(W//2+dx, 520+dy) for dx, dy in [(0,0),(-90,40),(-150,140),( -60,200),(60,200),(150,140),(90,40)]]
    add_glow(img, lambda d: d.line(pts, fill=CYAN, width=2), blur=16, alpha=0.7)
    for p in pts:
        add_glow(img, lambda d, p=p: d.ellipse([p[0]-4, p[1]-4, p[0]+4, p[1]+4], fill=WHITE), blur=10, alpha=0.9)
    text(img, (W//2, 700), "“We did not begin with a theory.”", F(40, bold=True), WHITE, glow=CYAN, align="center")
    text(img, (W//2, 820), "We began with a cage that refused to lie.", F(28), DIM, align="center")
    add_glow(img, lambda d: d.line([(200, 1000), (W-200, 1000)], fill=MAGENTA, width=2), blur=14, alpha=0.7)
    text(img, (W//2, 1080), "“Evidence or Silence.”", F(56, bold=True), GREEN, glow=GREEN, align="center")
    text(img, (W//2, 1200), "No claim leaves the system without three", F(28), WHITE, align="center")
    text(img, (W//2, 1244), "computationally distinct witnesses.", F(28), WHITE, align="center")
    text(img, (W//2, 1380), "Ω ← TRUST ∧ CODE", F(34, bold=True), CYAN, glow=CYAN, align="center")
    return img

# 3. AGENT CONSTELLATION
def p_constellation():
    img = new_page(); starfield(img, 180)
    nodes = {
        "ORION": (300, 380, CYAN),
        "ECHO":  (940, 300, PURPLE),
        "VECTOR":(760, 560, GREEN),
        "NOVA":  (360, 820, GOLD),
        "RAT":   (980, 880, MAGENTA),
        "CAT":   (620, 1080, CYAN),
    }
    edges = [("ORION","ECHO"),("ORION","VECTOR"),("ECHO","VECTOR"),("VECTOR","NOVA"),
             ("NOVA","RAT"),("RAT","CAT"),("CAT","ORION"),("VECTOR","CAT"),("ECHO","RAT")]
    def P(n): return nodes[n][0], nodes[n][1]
    for a, b in edges:
        add_glow(img, lambda d, a=a, b=b: d.line([P(a), P(b)], fill=DIM, width=2), blur=10, alpha=0.5)
    for name, (x, y, c) in nodes.items():
        add_glow(img, lambda d, x=x, y=y, c=c: d.ellipse([x-10, y-10, x+10, y+10], fill=c), blur=22, alpha=1.0)
        text(img, (x, y+18), name, F(26, bold=True), WHITE, glow=c, align="center")
    text(img, (W//2, 1290), "THE AGENT CONSTELLATION", F(40, bold=True), CYAN, glow=CYAN, align="center")
    text(img, (W//2, 1360), "Nine sovereign agents · one resonance field · entropy E = 0.0932", F(24), DIM, align="center")
    return img

# 4. ARCHITECTURE / TERMINAL
def p_arch():
    img = new_page(); starfield(img, 100)
    text(img, (W//2, 90), "ARCHITECTURE OVERVIEW", F(40, bold=True), CYAN, glow=CYAN, align="center")
    terminal(img, (90, 200, W-90, 900),
        "sovereign@snapkitty:~$ cat stack.txt",
        [("┌─ CONSTITUTIONAL BOOT (6 STAGES) ───────────────┐", CYAN),
         (" SHREW ▸ ILLUMINATE ▸ RAT ▸ ALIGNMENT ▸ CATCODE ▸ SOVEREIGN", GREEN),
         ("└─────────────────────────────────────────────────┘", CYAN),
         ("", WHITE),
         ("┌─ MULTI-WITNESS VERIFICATION (333) ──────────────┐", CYAN),
         ("  NT  number-theoretic   (exhaustive search)", WHITE),
         ("  ALG algebraic  Q(√5)   (φ identities)", WHITE),
         ("  IT  info-theoretic     (hash-chain audit)", WHITE),
         ("  rule: accept ⟺ ALL 3 agree", GREEN),
         ("└─────────────────────────────────────────────────┘", CYAN),
         ("", WHITE),
         (" seal_0 ▸ seal_1 ▸ seal_2 ▸ ... ▸ seal_n   (WORM)", MAGENTA),
         (" P(false positive) ≤ 2^-256", GOLD)])
    terminal(img, (90, 950, W-90, 1300),
        "sovereign@snapkitty:~$ swarm --status",
        [(" CLAIM ▸ SOLVE ▸ SUBMIT ▸ VERIFY ▸ CONVERGE", CYAN),
         (" universeSum → ∞   (monotonic convergence)", GREEN),
         (" 3 open problems · 9 seals · 5 verified theorems", WHITE)],
        accent=MAGENTA)
    text(img, (W//2, 1380), "Self-verifying. Append-only. Sovereign.", F(26), DIM, align="center")
    return img

# 5. WORM CHAIN NODES
def p_worm():
    img = new_page(); starfield(img, 120)
    text(img, (W//2, 90), "THE WORM CHAIN", F(42, bold=True), GREEN, glow=GREEN, align="center")
    text(img, (W//2, 150), "each block is a glowing celestial node", F(24), DIM, align="center")
    seals = [
        ("00", "THEOREMS_LOADED", "b062af4…51d2"),
        ("01", "φ² = φ + 1", "a8d72e…7c90"),
        ("02", "φ⁻¹ = φ − 1", "c1e9b3…22af"),
        ("03", "MULTI-WITNESS", "4f0a1d…9c41"),
        ("04", "LITERATURE_IMPORT", "77be20…0d18"),
        ("05", "COLLATZ_10K", "e23a55…1b6e"),
        ("06", "RAMSEY_R33", "19fd33…a1c0"),
        ("07", "ANCIENT_SORRY", "4b5654…0058"),
        ("08", "CLOSURE_PROVEN", "21b9bd…e606"),
    ]
    n = len(seals)
    cx = [W//2 + 360*math.cos(2*math.pi*i/n - math.pi/2) for i in range(n)]
    cy = [H//2 + 360 for i in range(n)]
    cy = [830 + 330*math.sin(2*math.pi*i/n - math.pi/2) for i in range(n)]
    cols = [CYAN, GREEN, GOLD, PURPLE, MAGENTA, CYAN, GREEN, GOLD, MAGENTA]
    for i in range(n):
        j = (i+1) % n
        add_glow(img, lambda d, i=i, j=j: d.line([(cx[i], cy[i]), (cx[j], cy[j])], fill=DIM, width=2), blur=10, alpha=0.45)
    for i, (idx, lab, hsh) in enumerate(seals):
        c = cols[i]
        add_glow(img, lambda d, i=i, c=c: d.ellipse([cx[i]-16, cy[i]-16, cx[i]+16, cy[i]+16], fill=c), blur=26, alpha=1.0)
        text(img, (cx[i], cy[i]-150), f"WORM#{idx}", F(24, bold=True), WHITE, glow=c, align="center")
        text(img, (cx[i], cy[i]-118), lab, F(18), DIM, align="center")
        text(img, (cx[i], cy[i]+30), hsh, F(16), c, align="center")
    text(img, (W//2, 1300), "∀k : seal_k.prev = hash(seal_{k-1})   ·   Ed25519 sealed", F(26), CYAN, glow=CYAN, align="center")
    return img

# 6. COSMIC INVARIANT SIEVE (10 gates)
def p_sieve():
    img = new_page(); starfield(img, 90); glitch_bg(img, 3, 0.12)
    text(img, (W//2, 80), "THE COSMIC INVARIANT SIEVE", F(38, bold=True), MAGENTA, glow=MAGENTA, align="center")
    text(img, (W//2, 138), "ten gates · one deterministic tripwire", F(24), DIM, align="center")
    gates = ["G1 Isabelle/HOL", "G2 Clingo SAT", "G3 Julia AST", "G4 Type Lattice",
             "G5 Borrow Graph", "G6 Linear Types", "G7 Hash Seal", "G8 WITNESS∧",
             "G9 Sieve Gate", "G10 INTERCAL"]
    cols = [CYAN, GREEN, GOLD, PURPLE, MAGENTA, CYAN, GREEN, GOLD, PURPLE, MAGENTA]
    # orbital layout
    cx, cy, R = W//2, 760, 380
    for i, g in enumerate(gates):
        a = 2*math.pi*i/len(gates) - math.pi/2
        x = cx + R*math.cos(a); y = cy + R*0.62*math.sin(a)
        c = cols[i]
        add_glow(img, lambda d, x=x, y=y, c=c: d.ellipse([x-13, y-13, x+13, y+13], fill=c), blur=20, alpha=1.0)
        text(img, (x, y-150), g, F(20, bold=True), WHITE, glow=c, align="center")
        text(img, (x, y+22), f"gate {i+1:02d}", F(15), DIM, align="center")
    add_glow(img, lambda d: d.ellipse([cx-40, cy-40, cx+40, cy+40], fill=WHITE), blur=30, alpha=1.0)
    text(img, (cx, cy-10), "SIEVE", F(22, bold=True), BG, align="center")
    text(img, (W//2, 1300), "Safe graphs compile. Seven violations rejected with real INTERCAL.", F(24), CYAN, glow=CYAN, align="center")
    return img

# 7. GATE ORBITALS (divider-ish schematic)
def p_gates():
    img = new_page(); starfield(img, 120)
    text(img, (W//2, 80), "GATE GEOMETRY", F(40, bold=True), PURPLE, glow=PURPLE, align="center")
    text(img, (W//2, 140), "orbital mechanics of verification", F(24), DIM, align="center")
    random.seed(11)
    for k in range(5):
        cx = random.randint(220, W-220); cy = random.randint(360, 980)
        R = random.randint(120, 240)
        c = random.choice([CYAN, GREEN, MAGENTA, GOLD])
        add_glow(img, lambda d, cx=cx, cy=cy, R=R, c=c: d.ellipse([cx-R, cy-R*0.7, cx+R, cy+R*0.7], outline=c, width=2), blur=14, alpha=0.6)
        ang = random.uniform(0, 2*math.pi)
        x = cx + R*math.cos(ang); y = cy + R*0.7*math.sin(ang)
        add_glow(img, lambda d, x=x, y=y, c=c: d.ellipse([x-12, y-12, x+12, y+12], fill=c), blur=22, alpha=1.0)
    text(img, (W//2, 1120), "Each gate is an orbit. A claim must clear all ten", F(26), WHITE, glow=PURPLE, align="center")
    text(img, (W//2, 1180), "before it is admitted to the chain.", F(26), WHITE, glow=PURPLE, align="center")
    return img

# 8. INTERCAL TRIPWIRE
def p_intercal():
    img = new_page(); starfield(img, 80); glitch_bg(img, 5, 0.10)
    text(img, (W//2, 80), "THE INTERCAL TRIPWIRE", F(40, bold=True), GREEN, glow=GREEN, align="center")
    terminal(img, (90, 180, W-90, 720),
        "borrow_chain.icn  —  COME FROM (99999)",
        [("  PLEASE ABSTAIN FROM BORROWING WITH INVALID LINEARITY", GREEN),
         ("  DO .1 <- #7", WHITE),
         ("  DO .2 <- #3", WHITE),
         ("  DO .3 <- .1 SUB .2              ❌  non-affine use", MAGENTA),
         ("  COME FROM (99999)              ✦ rejection sentinel", GOLD),
         ("", WHITE),
         ("  > gate rejected: V7_LINEAR_ESCAPE", MAGENTA),
         ("  > witness required before re-ingest", CYAN),
         ("  > five-nines never-defined label holds the line", GREEN)],
        accent=GREEN)
    text(img, (W//2, 820), "KILL SWITCH 9999", F(40, bold=True), MAGENTA, glow=MAGENTA, align="center")
    text(img, (W//2, 890), "A PLEASE-saturated artifact failed to route.", F(26), WHITE, align="center")
    text(img, (W//2, 934), "Observed. Cause correlated. Mechanism open.", F(26), GOLD, glow=GOLD, align="center")
    terminal(img, (90, 1010, W-90, 1300),
        "experiment.log",
        [("  run#41  PLEASE-load 0.91  → router: DROP", MAGENTA),
         ("  run#42  PLEASE-load 0.62  → router: PASS", GREEN),
         ("  conclusion: structurally-significant token correlation", CYAN),
         ("  caveat: causal mechanism NOT yet isolated", GOLD)],
        accent=MAGENTA)
    return img

# 9. EXPERIMENT LOG / TELEMETRY
def p_telemetry():
    img = new_page(); glitch_bg(img, 2, 0.22)
    d = ImageDraw.Draw(img)
    d.rectangle([0, 0, W, H], fill=(3, 6, 12))
    starfield(img, 60)
    text(img, (W//2, 80), "EXPERIMENT LOG", F(40, bold=True), CYAN, glow=CYAN, align="center")
    text(img, (W//2, 140), "mission telemetry · sieve sweep 2026", F(24), DIM, align="center")
    rows = [
        ("GATE", "INPUT", "RESULT", "WITNESS"),
        ("G1", "proof_obligation.thy", "PASS", "NT+ALG"),
        ("G2", "schedule.lp", "SAT", "ALG"),
        ("G3", "module.jl", "STRUCT-OK", "IT"),
        ("G5", "borrow.cfg", "REJECT V3", "ALG"),
        ("G6", "tensor.toml", "REJECT V5", "ALG"),
        ("G9", "sieve.run", "CONVERGE", "ALL"),
        ("G10", "tripwire.icn", "COME FROM", "IT"),
    ]
    y = 240; x0 = 110; lh = 92
    d.line([(x0, y+50), (W-x0, y+50)], fill=CYAN, width=2)
    for i, (a, b, c, e) in enumerate(rows):
        col = DIM if i == 0 else WHITE
        rc = GOLD if (i>0 and "REJECT" in c) else (GREEN if (i>0 and c in ("PASS","SAT","CONVERGE","COME FROM")) else col)
        text(img, (x0, y+70), a, F(26, bold=(i==0)), col)
        text(img, (x0+180, y+70), b, F(24), col)
        text(img, (x0+640, y+70), c, F(26, bold=True), rc)
        text(img, (x0+900, y+70), e, F(24), DIM)
        y += lh
        d.line([(x0, y+50), (W-x0, y+50)], fill=(30, 40, 60), width=1)
    text(img, (W//2, 1180), "7 violation classes · each a unique, real INTERCAL artifact", F(24), MAGENTA, glow=MAGENTA, align="center")
    return img

# 10. ECHO RESEARCH LAB
def p_echo():
    img = new_page(); glitch_bg(img, 4, 0.55)
    d = ImageDraw.Draw(img)
    d.rectangle([0,0,W,H], fill=(10,4,20))
    img = Image.blend(img, GLITCH[4].resize((W,H)), 0.5)
    add_glow(img, lambda dd: dd.text((W//2, 120), "ECHO", font=F(80, bold=True), fill=PURPLE), blur=40, alpha=1.0)
    text(img, (W//2, 230), "RESEARCH LAB · GLITCH DIVISION", F(26), MAGENTA, glow=MAGENTA, align="center")
    terminal(img, (110, 320, W-110, 760),
        "echo@lab:~$ cat notes.md",
        [("  purple field = symbolic residue of rejected proofs", WHITE),
         ("  glitch art := visual hash of seal_i", PURPLE),
         ("  each WORM link binds prev_hash + 7 invariants", CYAN),
         ("  art is the audit, the audit is the art", GREEN)],
        accent=PURPLE)
    text(img, (W//2, 880), "“The residue is data. The glitch is proof.”", F(34, bold=True), WHITE, glow=PURPLE, align="center")
    text(img, (W//2, 980), "9 links · SHA-256 chain · minted to snapkitty-chain", F(24), DIM, align="center")
    return img

# 11. QUANTUM SYMBOLISM
def p_quantum():
    img = new_page(); glitch_bg(img, 7, 0.30)
    text(img, (W//2, 80), "QUANTUM SYMBOLISM", F(40, bold=True), GOLD, glow=GOLD, align="center")
    # draw symbolic schema: circle + triangle + lattice
    cx, cy = W//2, 720
    add_glow(img, lambda d: d.ellipse([cx-260, cy-260, cx+260, cy+260], outline=CYAN, width=2), blur=14, alpha=0.6)
    add_glow(img, lambda d: d.polygon([(cx, cy-200),(cx-180, cy+140),(cx+180, cy+140)], outline=MAGENTA, width=2), blur=14, alpha=0.6)
    for i in range(6):
        a = 2*math.pi*i/6
        x = cx+200*math.cos(a); y = cy+200*math.sin(a)
        add_glow(img, lambda d, x=x, y=y: d.ellipse([x-7, y-7, x+7, y+7], fill=GOLD), blur=16, alpha=1.0)
    text(img, (cx, cy-30), "I₄", F(40, bold=True), WHITE, align="center")
    text(img, (W//2, 1100), "Lean · topology · UTQC proof circuits", F(28), CYAN, glow=CYAN, align="center")
    text(img, (W//2, 1160), "J₃(𝕆) ⊗ ℍ  —  108 dimensions  —  E₇ invariant", F(26), GREEN, glow=GREEN, align="center")
    text(img, (W//2, 1240), "the unique quartic that encodes 4D 𝒩=8 supergravity", F(24), DIM, align="center")
    return img

# 12. AGENT PROFILE — ORION
def p_orion():
    img = new_page(); starfield(img, 120)
    c = CYAN
    add_glow(img, lambda d: d.ellipse([W//2-160, 200, W//2+160, 520], outline=c, width=3), blur=20, alpha=0.7)
    # sigil
    cx, cy = W//2, 360
    for r in (140, 100, 60):
        add_glow(img, lambda d, r=r: d.ellipse([cx-r, cy-r, cx+r, cy+r], outline=c, width=2), blur=12, alpha=0.6)
    add_glow(img, lambda d: d.line([(cx-140, cy),(cx+140, cy)], fill=c, width=2), blur=10, alpha=0.5)
    add_glow(img, lambda d: d.line([(cx, cy-140),(cx, cy+140)], fill=c, width=2), blur=10, alpha=0.5)
    add_glow(img, lambda d: d.ellipse([cx-8, cy-8, cx+8, cy+8], fill=WHITE), blur=18, alpha=1.0)
    text(img, (W//2, 600), "ORION", F(64, bold=True), WHITE, glow=c, align="center")
    text(img, (W//2, 690), "CONSTELLATION PRIME · WITNESS COORDINATOR", F(26), c, glow=c, align="center")
    terminal(img, (140, 800, W-140, 1180),
        "agent://orion",
        [("  role     : align NT + ALG + IT consensus", WHITE),
         ("  color    : cyan   #3cdcff", c),
         ("  sigil    : nested rings + cross", GREEN),
         ("  motto    : 'Three see what one cannot.'", GOLD)],
        accent=c)
    text(img, (W//2, 1280), "“Three see what one cannot.”", F(30, bold=True), WHITE, glow=c, align="center")
    return img

# 13. AGENT PROFILE — ECHO + VECTOR
def p_agents2():
    img = new_page(); starfield(img, 100)
    # ECHO left
    c1 = PURPLE
    add_glow(img, lambda d: d.ellipse([330-120, 250, 330+120, 490], outline=c1, width=3), blur=20, alpha=0.7)
    cx, cy = 330, 370
    add_glow(img, lambda d: d.polygon([(cx, cy-100),(cx-90, cy+70),(cx+90, cy+70)], outline=c1, width=2), blur=12, alpha=0.6)
    add_glow(img, lambda d: d.ellipse([cx-100, cy-30, cx+100, cy+130], outline=c1, width=2), blur=12, alpha=0.6)
    text(img, (330, 560), "ECHO", F(48, bold=True), WHITE, glow=c1, align="center")
    text(img, (330, 630), "GLITCH DIVISION", F(20), c1, align="center")
    # VECTOR right
    c2 = GREEN
    add_glow(img, lambda d: d.ellipse([910-120, 250, 910+120, 490], outline=c2, width=3), blur=20, alpha=0.7)
    cx, cy = 910, 370
    for k in range(3):
        a0 = k*2*math.pi/3 - math.pi/2
        add_glow(img, lambda d, a0=a0: d.line([(cx, cy),(cx+110*math.cos(a0), cy+110*math.sin(a0))], fill=c2, width=2), blur=10, alpha=0.5)
    add_glow(img, lambda d: d.ellipse([cx-10, cy-10, cx+10, cy+10], fill=WHITE), blur=18, alpha=1.0)
    text(img, (910, 560), "VECTOR", F(48, bold=True), WHITE, glow=c2, align="center")
    text(img, (910, 630), "LINEAR-TYPE WARDEN", F(20), c2, align="center")
    terminal(img, (140, 760, W-140, 1120),
        "roster://agents",
        [("  ECHO   purple  glitch art + residue audit      ", c1),
         ("  VECTOR green   affine borrow enforcement        ", c2),
         ("  NOVA   gold    convergence accounting           ", GOLD),
         ("  RAT    magenta chain ratchet                    ", MAGENTA),
         ("  CAT    cyan    categorical closure             ", CYAN)],
        accent=PURPLE)
    text(img, (W//2, 1220), "Nine agents. One field. Every claim watched.", F(26), WHITE, glow=PURPLE, align="center")
    return img

# 14. ROADMAP — proven / observed / hypothesized
def p_roadmap():
    img = new_page(); starfield(img, 90)
    text(img, (W//2, 90), "ROADMAP", F(44, bold=True), GREEN, glow=GREEN, align="center")
    text(img, (W//2, 150), "honesty is the protocol", F(26), DIM, align="center")
    colw = (W-260)//3
    headers = [("PROVEN", GREEN), ("OBSERVED", GOLD), ("HYPOTHESIZED", MAGENTA)]
    proven = ["φ² = φ + 1", "φ⁻¹ = φ − 1", "Collatz ≤ 10,000", "Ramsey R(3,3)=6", "Ancient Sorry closure", "WORM seal ≤ 2^-256"]
    observed = ["router drop on PLEASE-load", "agent codegen failures", "INTERCAL ingest outcomes", "9-link chain mints", "entropy E = 0.0932"]
    hyp = ["invariant-centered AI", "router token sensitivity", "witness logical-error bound", "I₄ E₇ uniqueness (axiom)"]
    for i, (ht, hc) in enumerate(headers):
        x = 130 + i*colw
        add_glow(img, lambda d, x=x, hc=hc: d.line([(x, 250),(x+colw-30, 250)], fill=hc, width=2), blur=12, alpha=0.7)
        text(img, (x, 270), ht, F(28, bold=True), WHITE, glow=hc)
        items = [proven, observed, hyp][i]
        y = 340
        for it in items:
            text(img, (x, y), "• " + it, F(22), WHITE)
            y += 70
    text(img, (W//2, 1300), "The seal bounds forgery. It does not bound correlated error — yet.", F(24), GOLD, glow=GOLD, align="center")
    return img

# 15. CLOSING
def p_closing():
    img = COVER_IMG.copy()
    img = Image.blend(img, Image.new("RGB", (W, H), BG), 0.30)
    img = glitch_bg(img, 8, 0.20)
    vig = Image.new("L", (W, H), 0); vd = ImageDraw.Draw(vig)
    vd.ellipse([-300, -300, W+300, H+300], fill=255); vig = vig.filter(ImageFilter.GaussianBlur(200))
    img = Image.composite(img, Image.new("RGB", (W, H), BG), vig)
    add_glow(img, lambda d: d.text((W//2, 560), "Ω", font=F(140), fill=CYAN), blur=40, alpha=1.0)
    text(img, (W//2, 760), "THE CAGE HOLDS.", F(64, bold=True), GREEN, glow=GREEN, align="center")
    text(img, (W//2, 860), "No sorry remains.", F(44, bold=True), WHITE, glow=CYAN, align="center")
    add_glow(img, lambda d: d.line([(300, 1000), (W-300, 1000)], fill=MAGENTA, width=2), blur=14, alpha=0.7)
    text(img, (W//2, 1060), "Evidence or Silence.", F(38, bold=True), MAGENTA, glow=MAGENTA, align="center")
    text(img, (W//2, 1240), "SNAPKITTYWEST · Sovereign Compute · 2026", F(26), DIM, align="center")
    text(img, (W//2, 1290), "github.com/SNAPKITTYWEST", F(22), DIM, align="center")
    text(img, (W//2, 1330), "doi.org/10.5281/zenodo.21132094", F(22), DIM, align="center")
    return img

# ---- assemble ----
builders = [
    p_cover, p_mission, p_constellation, p_arch, p_worm,
    p_sieve, p_gates, p_intercal, p_telemetry, p_echo,
    p_quantum, p_orion, p_agents2, p_roadmap, p_closing,
]
os.makedirs(os.path.dirname(OUT), exist_ok=True)
imgs = [b() for b in builders]

from reportlab.pdfgen import canvas
from reportlab.lib.utils import ImageReader
PW, PH = W/150.0*72.0, H/150.0*72.0  # points
c = canvas.Canvas(OUT, pagesize=(PW, PH))
for im in imgs:
    c.setFillColorRGB(0, 0, 0)
    c.rect(0, 0, PW, PH, fill=1, stroke=0)
    c.drawImage(ImageReader(im), 0, 0, width=PW, height=PH, mask="auto")
    c.showPage()
c.setTitle("SnapKitty Cosmic Field Manifesto")
c.save()
print("WROTE", OUT, "pages", len(imgs))