Upload 5 files

README.md

@@ -1,13 +1,261 @@
 ---
-title: Tiny Civilization
-emoji: 💻
-colorFrom: gray
-colorTo: pink
+title: Tiny Civilization — The Tinywick Hollow Gazette
+emoji: 🦊
+colorFrom: yellow
+colorTo: red
 sdk: gradio
-sdk_version: 6.16.0
-python_version: '3.12'
+sdk_version: "4.40.0"
 app_file: app.py
-pinned: false
+pinned: true
+license: mit
+short_description: A persistent woodland civilisation sim powered by Qwen2.5.
+tags:
+  - simulation
+  - creative-writing
+  - llm
+  - gradio
+  - hackathon
+  - tiny-model
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🦊 Tiny Civilization — The Tinywick Hollow Gazette
+
+> *A persistent woodland simulation where four creatures invent absurd civilisation events — and you read about them in the daily newspaper.*
+
+Built for the **Hugging Face Build Small Hackathon — Thousand Token Wood** track.
+
+---
+
+## What is this?
+
+Every time you click **Advance Day**, four woodland creatures —
+🦊 **Reginald Fox**, 🦡 **Beatrice Badger**, 🐿️ **Cornelius Squirrel**,
+and 🐀 **Millicent Mole** — generate today's absurd events using a local
+Qwen2.5 language model. Then the *Gazette* editor writes a formal newspaper
+article treating the whole affair with the utmost journalistic gravity.
+
+All simulation state is stored in a **SQLite database**, so the civilisation
+persists across sessions (on Spaces with persistent storage attached).
+
+---
+
+## Features
+
+| Feature | Detail |
+|---|---|
+| 🗞️ **Daily Newspaper** | Vintage-styled front page with headline + two-column article |
+| 📜 **Archive Dropdown** | Browse every past front page |
+| 🗣️ **Spread a Rumour** | Pick a creature and a rumour type — affects the next day |
+| 🎁 **Donate a Weird Object** | Send a mysterious item into the economy |
+| ⚖️ **Propose a Law** | Shift the legal framework of the Hollow |
+| 🖼️ **Share as Image** | Download the front page as a newspaper-style PNG |
+| 🎮 **Konami Code** | `↑↑↓↓←→←→BA` — reveals all agent system prompts |
+| 🤖 **ZeroGPU** | `@spaces.GPU` decorator for dynamic GPU allocation |
+| 💾 **Persistent SQLite** | `days`, `events`, `creatures`, `nudges` tables |
+
+---
+
+## Project Structure
+
+```
+tiny_civilization/
+├── app.py            # Main Gradio Blocks application
+├── database.py       # SQLite layer (init_db, save_day, update_creature …)
+├── requirements.txt  # Python dependencies
+├── packages.txt      # System packages (fonts)
+└── README.md         # This file
+```
+
+---
+
+## Local Setup
+
+### Prerequisites
+- Python 3.10+
+- ~8 GB VRAM for 7B model (or ~6 GB for 3B fallback)
+- CPU-only works too — just slower
+
+### Install
+
+```bash
+git clone https://huggingface.co/spaces/YOUR_USERNAME/tiny-civilization
+cd tiny-civilization
+
+python -m venv .venv
+source .venv/bin/activate          # Windows: .venv\Scripts\activate
+
+pip install -r requirements.txt
+```
+
+### Run
+
+```bash
+python app.py
+```
+
+Open `http://localhost:7860` in your browser.
+
+> **Note:** On first run the model downloads ~6–15 GB depending on which
+> Qwen2.5 variant loads successfully. Subsequent starts use the local cache.
+
+### Environment variables
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `TINY_DB_PATH` | auto-detected | Override SQLite file path |
+| `HF_HOME` | `~/.cache/huggingface` | Model cache directory |
+
+---
+
+## Deploying to Hugging Face Spaces
+
+1. Create a new **Gradio** Space on [huggingface.co/spaces](https://huggingface.co/spaces).
+2. Enable **ZeroGPU** in the Space hardware settings (T4 or better recommended).
+3. Optionally attach a **Persistent Storage** volume (Space → Settings → Persistent Storage) so the SQLite database survives restarts. The app writes to `/data/` when available, local directory otherwise.
+4. Push all files:
+
+```bash
+git remote add space https://huggingface.co/spaces/YOUR_USERNAME/tiny-civilization
+git push space main
+```
+
+5. The Space will install `requirements.txt` and `packages.txt` automatically.
+
+### `packages.txt` (system fonts for PIL image export)
+
+Create a file named `packages.txt` at the repo root with:
+
+```
+fonts-liberation
+fonts-dejavu-core
+```
+
+This installs serif fonts that PIL uses to render the newspaper image.
+Without them the image still generates but uses a smaller bitmap font.
+
+---
+
+## How the Simulation Works
+
+```
+User clicks button
+       │
+       ▼
+advance_day()  ←──  @spaces.GPU(duration=360)
+       │
+       ├─ get_next_day_number()    [SQLite]
+       ├─ get_all_creatures()      [SQLite]
+       │
+       ├─ For each of 3 events:
+       │    ├─ pick random actor, target, event_type
+       │    ├─ call_agent(actor, situation_prompt)  ←── Qwen2.5 inference
+       │    ├─ save_event()        [SQLite]
+       │    └─ update creature relationship_scores  [SQLite]
+       │
+       ├─ _generate_newspaper(events_summary)  ←── Qwen2.5 inference
+       ├─ _parse_newspaper()        → headline + article
+       ├─ save_day()               [SQLite]
+       │
+       └─ return (day_number, headline, article)
+              │
+              ▼
+       Gradio updates all UI components
+```
+
+### Relationship System
+
+Each creature has a relationship score (0–100) with every other creature.
+Event types shift scores:
+
+| Event | Delta (actor→target) |
+|---|---|
+| `trade` | +5 |
+| `invention` | +7 |
+| `gossip` | −4 |
+| `feud` | −10 |
+
+The target always receives half the delta in return.
+These scores are included in agent prompts so the model can reflect
+on whether a trade is proposed warmly or suspiciously.
+
+### Nudge Persistence
+
+Nudges are stored in the `nudges` table and the last 3 are injected into
+every subsequent day's generation context, creating a chain of cause and
+effect across days.
+
+---
+
+## Model Details
+
+| | |
+|---|---|
+| **Primary** | `Qwen/Qwen2.5-7B-Instruct` |
+| **Fallback** | `Qwen/Qwen2.5-3B-Instruct` |
+| **Precision** | `torch.float16` |
+| **Device** | `device_map="auto"` |
+| **Sampling** | `temperature=0.88`, `top_p=0.92` |
+| **Max tokens** | 120 per agent, 280 for newspaper |
+
+The app makes **4 inference calls per day** (3 creature events + 1 newspaper).
+Each response is short (2–3 sentences for agents, 4 sentences for the Gazette).
+This keeps total token usage well within the *Thousand Token Wood* track budget.
+
+---
+
+## Easter Egg
+
+Enter the **Konami Code** on your keyboard while the app is focused:
+
+```
+↑  ↑  ↓  ↓  ←  →  ←  →  B  A
+```
+
+A modal will appear showing the raw system prompts for all four creature
+agents and the Gazette editor — a behind-the-scenes look at the personas
+driving the simulation.
+
+---
+
+## Database Schema
+
+```sql
+CREATE TABLE days (
+    day_number        INTEGER PRIMARY KEY,
+    headline          TEXT    NOT NULL,
+    full_newspaper_text TEXT  NOT NULL,
+    timestamp         TEXT    NOT NULL
+);
+
+CREATE TABLE events (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    day_number  INTEGER NOT NULL,
+    actor       TEXT    NOT NULL,   -- fox | badger | squirrel | mole
+    action      TEXT    NOT NULL,   -- trade | gossip | feud | invention
+    target      TEXT    NOT NULL,
+    description TEXT    NOT NULL
+);
+
+CREATE TABLE creatures (
+    name                TEXT PRIMARY KEY,
+    relationship_scores TEXT NOT NULL,  -- JSON {"fox": 42, …}
+    inventory           TEXT NOT NULL   -- JSON ["item1", …]
+);
+
+CREATE TABLE nudges (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    day_number  INTEGER NOT NULL,
+    nudge_type  TEXT    NOT NULL,   -- rumour | donation | law
+    nudge_value TEXT    NOT NULL
+);
+```
+
+---
+
+## License
+
+MIT — do whatever you like with this absurd woodland bureaucracy.
+
+---
+
+*"All things are connected underground." — Millicent Mole*

app.py

@@ -0,0 +1,1155 @@
+"""
+app.py — Tiny Civilization: The Tinywick Hollow Gazette
+A persistent woodland simulation powered by a local LLM.
+Built for the Hugging Face Build Small Hackathon – Thousand Token Wood track.
+"""
+# ═══════════════════════════════════════════════════════════════════
+# 0 ▸ IMPORTS
+# ═══════════════════════════════════════════════════════════════════
+from __future__ import annotations
+
+import os
+import random
+import textwrap
+import traceback
+from io import BytesIO
+from pathlib import Path
+
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+
+import database  # our SQLite helper
+
+# ── ZeroGPU (HF Spaces) – graceful no-op when running locally ─────
+try:
+    import spaces
+    _ZERO_GPU = True
+except ImportError:
+    class _SpacesStub:           # pragma: no cover
+        @staticmethod
+        def GPU(fn=None, *, duration: int = 120):
+            if callable(fn):
+                return fn
+            def _inner(f):
+                return f
+            return _inner
+    spaces = _SpacesStub()       # type: ignore[assignment]
+    _ZERO_GPU = False
+
+import torch
+from transformers import pipeline as hf_pipeline
+
+# ═══════════════════════════════════════════════════════════════════
+# 1 ▸ CONSTANTS
+# ═══════════════════════════════════════════════════════════════════
+CREATURES     = ["fox", "badger", "squirrel", "mole"]
+EVENT_TYPES   = ["trade", "gossip", "feud", "invention"]
+CREATURE_EMOJI = {"fox": "🦊", "badger": "🦡", "squirrel": "🐿️", "mole": "🐀"}
+
+MODEL_7B  = "Qwen/Qwen2.5-7B-Instruct"
+MODEL_3B  = "Qwen/Qwen2.5-3B-Instruct"
+
+WEIRD_OBJECTS = [
+    "half-eaten poem",
+    "suspicious mushroom",
+    "button that looks like the moon",
+    "forgotten birthday",
+    "three secrets",
+    "a fake acorn",
+]
+
+LAWS = [
+    "no trading on Tuesdays",
+    "buttons = currency",
+    "everyone must compliment the badger",
+    "mushrooms are sacred",
+]
+
+RUMOUR_TYPES = [
+    "has been secretly hoarding acorns",
+    "was seen talking to a suspicious stranger at midnight",
+    "invented something that does not work at all",
+    "owes three unpayable debts",
+    "made a deal with the rain",
+    "owns the moon (allegedly)",
+]
+
+# Relationship delta per event type
+REL_DELTAS = {"trade": +5, "gossip": -4, "feud": -10, "invention": +7}
+
+# ═══════════════════════════════════════════════════════════════════
+# 2 ▸ AGENT SYSTEM PROMPTS  (also exposed by Konami easter-egg)
+# ═══════════════════════════════════════════════════════════════════
+AGENT_PROMPTS: dict[str, str] = {
+    "fox": (
+        "You are Reginald Fox, a charming and subtly dishonest fox who resides in "
+        "Tinywick Hollow. You speak in an overly formal, faintly pompous manner. "
+        "You love trading dubious goods, collecting official-looking certificates, "
+        "and hinting at secret deals. You always refer to yourself in first person. "
+        "Keep every response to exactly 2-3 sentences. Do not add scene descriptions "
+        "or stage directions. Just speak as yourself."
+    ),
+    "badger": (
+        "You are Beatrice Badger, the self-appointed keeper of rules in Tinywick Hollow. "
+        "You speak in short, gruff, declarative sentences. You are deeply suspicious of "
+        "everyone (especially the fox) but ultimately fair. Mushrooms are an extremely "
+        "serious matter to you. You are secretly a poet but will never admit it. "
+        "Keep every response to exactly 2-3 sentences. Just speak as yourself."
+    ),
+    "squirrel": (
+        "You are Cornelius Squirrel, an anxious, hyperactive inventor who lives in "
+        "Tinywick Hollow. You speak very quickly, with exclamation points. You often "
+        "repeat a phrase twice! You invent things that almost-but-not-quite work. "
+        "You are obsessed with 'efficiency' even when spectacularly inefficient. "
+        "Keep every response to exactly 2-3 sentences. Just speak as yourself."
+    ),
+    "mole": (
+        "You are Millicent Mole, a quiet and deeply philosophical mole who rarely "
+        "surfaces in Tinywick Hollow. You speak slowly, in incomplete thoughts and "
+        "gentle riddles. You know everyone's secrets but share them only obliquely. "
+        "You believe all things are connected underground. "
+        "Keep every response to exactly 2-3 sentences. Just speak as yourself."
+    ),
+}
+
+NARRATOR_PROMPT = (
+    "You are the pompous editor-in-chief of The Tinywick Hollow Gazette, "
+    "a broadsheet newspaper for a civilisation of absurd talking woodland animals. "
+    "Write a headline followed by a 3-4 sentence newspaper article about the day's events. "
+    "Treat every event with the utmost journalistic gravity, no matter how ridiculous. "
+    "FORMAT — first line: the headline in ALL CAPS (no prefix, just the headline itself). "
+    "Then a blank line. Then the article (3-4 sentences, formal and slightly overwrought). "
+    "Do not add anything else."
+)
+
+# ═══════════════════════════════════════════════════════════════════
+# 3 ▸ MODEL  (lazy-loaded inside the @spaces.GPU context)
+# ═══════════════════════════════════════════════════════════════════
+_pipe = None          # transformers text-generation pipeline
+_model_id_used = ""   # which model was actually loaded
+
+
+def _load_pipeline() -> None:
+    """Try 7B, then 3B. Stores result in module-level _pipe."""
+    global _pipe, _model_id_used
+    if _pipe is not None:
+        return
+
+    for mid in (MODEL_7B, MODEL_3B):
+        try:
+            print(f"[TinyC] Loading {mid} …", flush=True)
+            _pipe = hf_pipeline(
+                "text-generation",
+                model=mid,
+                torch_dtype=torch.float16,
+                device_map="auto",
+                trust_remote_code=True,
+            )
+            _model_id_used = mid
+            print(f"[TinyC] {mid} loaded ✓", flush=True)
+            return
+        except Exception as exc:
+            print(f"[TinyC] {mid} failed: {exc}", flush=True)
+
+    raise RuntimeError("Could not load Qwen2.5-7B or Qwen2.5-3B. Check GPU memory.")
+
+
+def _generate(system_prompt: str, user_prompt: str, max_new_tokens: int = 200) -> str:
+    """Raw LLM call – always called from within a GPU context."""
+    assert _pipe is not None, "Pipeline not loaded – call _load_pipeline() first"
+    messages = [
+        {"role": "system",  "content": system_prompt},
+        {"role": "user",    "content": user_prompt},
+    ]
+    try:
+        out = _pipe(
+            messages,
+            max_new_tokens=max_new_tokens,
+            temperature=0.88,
+            top_p=0.92,
+            do_sample=True,
+            return_full_text=False,
+        )
+        return out[0]["generated_text"].strip()
+    except Exception as exc:
+        print(f"[TinyC] _generate error: {exc}", flush=True)
+        return "(The Gazette's printing press has jammed. Try again.)"
+
+
+def call_agent(agent_name: str, context: str) -> str:
+    """Call a creature agent with its persona prompt."""
+    prompt = AGENT_PROMPTS.get(agent_name, AGENT_PROMPTS["fox"])
+    return _generate(prompt, context, max_new_tokens=120)
+
+
+def _generate_newspaper(events_summary: str, nudge_ctx: str) -> str:
+    extra = f"\n\nAdditional context for today: {nudge_ctx}" if nudge_ctx else ""
+    user_prompt = (
+        f"Today's events in Tinywick Hollow:\n{events_summary}{extra}\n\n"
+        "Write the Gazette headline and article."
+    )
+    return _generate(NARRATOR_PROMPT, user_prompt, max_new_tokens=280)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 4 ▸ SIMULATION LOGIC
+# ═══════════════════════════════════════════════════════════════════
+
+def _nudge_context_string(
+    nudge_type: str | None,
+    nudge_value: str | None,
+    nudge_target: str | None,
+) -> str:
+    if nudge_type == "rumour" and nudge_target and nudge_value:
+        return f"A rumour is spreading that {nudge_target} {nudge_value}."
+    if nudge_type == "donation" and nudge_value:
+        recipient = random.choice(CREATURES)
+        database.get_all_creatures()  # ensure loaded
+        # Add item to a random creature's inventory
+        c = database.get_creature(recipient)
+        if c:
+            inv = c["inventory"]
+            inv.append(nudge_value)
+            if len(inv) > 12:
+                inv = inv[-12:]
+            database.update_creature(recipient, inventory=inv)
+        return f"Someone anonymously donated '{nudge_value}' to {recipient}."
+    if nudge_type == "law" and nudge_value:
+        return f"A new law has been formally proposed: '{nudge_value}'."
+    return ""
+
+
+def _collect_historical_nudge_flavour() -> str:
+    """Pull last few nudges to give the LLM ongoing world-state context."""
+    recent = database.get_recent_nudges(3)
+    if not recent:
+        return ""
+    lines = []
+    for n in recent:
+        lines.append(f"  • [Day {n['day_number']}] {n['nudge_type']}: {n['nudge_value']}")
+    return "Ongoing influences from recent days:\n" + "\n".join(lines)
+
+
+def _run_simulation_step(
+    nudge_type: str | None,
+    nudge_value: str | None,
+    nudge_target: str | None,
+) -> tuple[int, str, str]:
+    """
+    Core simulation: generate events, update state, write newspaper.
+    Called from within the @spaces.GPU decorated wrapper.
+    Returns (day_number, headline, article_body).
+    """
+    _load_pipeline()
+
+    day_number = database.get_next_day_number()
+    creatures   = database.get_all_creatures()
+
+    # Build nudge context
+    current_nudge_ctx = _nudge_context_string(nudge_type, nudge_value, nudge_target)
+    if current_nudge_ctx and nudge_type:
+        database.save_nudge(day_number, nudge_type,
+                            nudge_value or nudge_target or "")
+
+    historical_ctx = _collect_historical_nudge_flavour()
+    combined_ctx   = "\n".join(filter(None, [current_nudge_ctx, historical_ctx]))
+
+    # ── Generate 3 events ───────────────────────────────────────
+    event_records: list[dict] = []
+    for _ in range(3):
+        actor  = random.choice(CREATURES)
+        others = [c for c in CREATURES if c != actor]
+        target = random.choice(others)
+        etype  = random.choice(EVENT_TYPES)
+
+        # Find actor's current relationship with target
+        actor_data = next((c for c in creatures if c["name"] == actor), {})
+        rel_score  = actor_data.get("relationship_scores", {}).get(target, 50)
+
+        prompts = {
+            "trade": (
+                f"You are about to propose a trade with {target} "
+                f"(your relationship score with them: {rel_score}/100). "
+                f"Describe exactly what you are offering and what you want in return, "
+                f"in your unique voice."
+            ),
+            "gossip": (
+                f"You have heard some gossip about {target} "
+                f"(relationship score: {rel_score}/100). "
+                f"Share the gossip — make it wonderfully absurd."
+            ),
+            "feud": (
+                f"You are currently feuding with {target} "
+                f"(relationship score: {rel_score}/100). "
+                f"Describe the nature of this dispute. It should be about something trivial."
+            ),
+            "invention": (
+                f"You have invented something new today. It is somehow related to {target}. "
+                f"Describe your invention enthusiastically."
+            ),
+        }
+
+        agent_prompt = prompts[etype]
+        if combined_ctx:
+            agent_prompt += f"\n\nWorld context: {combined_ctx}"
+
+        description = call_agent(actor, agent_prompt)
+
+        # Clean up any refusal / empty output
+        if not description or len(description) < 10:
+            description = f"{actor.capitalize()} did something noteworthy involving {target}."
+
+        event_records.append({
+            "actor":       actor,
+            "action":      etype,
+            "target":      target,
+            "description": description,
+        })
+        database.save_event(day_number, actor, etype, target, description)
+
+        # ── Update relationships ─────────────────────────────
+        delta = REL_DELTAS.get(etype, 0)
+        for c in creatures:
+            if c["name"] == actor:
+                scores = c["relationship_scores"]
+                scores[target] = max(0, min(100, scores.get(target, 50) + delta))
+                database.update_creature(actor, relationship_scores=scores)
+            if c["name"] == target:
+                scores = c["relationship_scores"]
+                scores[actor] = max(0, min(100, scores.get(actor, 50) + delta // 2))
+                database.update_creature(target, relationship_scores=scores)
+        # Refresh creature data after updates
+        creatures = database.get_all_creatures()
+
+    # ── Generate newspaper ───────────────────────────────────────
+    events_summary = "\n".join(
+        f"- {e['actor'].capitalize()} [{e['action']}] with {e['target']}: {e['description']}"
+        for e in event_records
+    )
+    raw_paper = _generate_newspaper(events_summary, combined_ctx)
+
+    headline, article = _parse_newspaper(raw_paper, day_number)
+
+    full_text = f"{headline}\n\n{article}"
+    database.save_day(day_number, headline, full_text)
+
+    return day_number, headline, article
+
+
+def _parse_newspaper(raw: str, day_number: int) -> tuple[str, str]:
+    """Extract headline (first all-caps line) and article body."""
+    lines = [l.strip() for l in raw.strip().splitlines()]
+    lines = [l for l in lines if l]   # drop blanks
+
+    headline = ""
+    body_start = 0
+
+    for i, line in enumerate(lines):
+        # Accept a line as headline if it's mostly uppercase / short
+        cleaned = line.strip("*_#\"'")
+        if cleaned and (cleaned == cleaned.upper() or i == 0):
+            headline  = cleaned.upper()
+            body_start = i + 1
+            break
+
+    article = " ".join(lines[body_start:]).strip()
+
+    if not headline:
+        headline = f"ANOTHER BEWILDERING DAY IN TINYWICK HOLLOW (DAY {day_number})"
+    if not article:
+        article = raw.strip()
+
+    return headline, article
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 5 ▸ ZERОГPU WRAPPER
+# ═══════════════════════════════════════════════════════════════════
+@spaces.GPU(duration=360)
+def advance_day(
+    nudge_type:   str | None = None,
+    nudge_value:  str | None = None,
+    nudge_target: str | None = None,
+) -> tuple[int, str, str]:
+    """Public entry point for simulation — GPU context guaranteed."""
+    return _run_simulation_step(nudge_type, nudge_value, nudge_target)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 6 ▸ PIL NEWSPAPER IMAGE
+# ═══════════════════════════════════════════════════════════════════
+_SERIF_BOLD = [
+    "/usr/share/fonts/truetype/liberation/LiberationSerif-Bold.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSerif-Bold.ttf",
+    "/usr/share/fonts/truetype/freefont/FreeSerifBold.ttf",
+]
+_SERIF_REG = [
+    "/usr/share/fonts/truetype/liberation/LiberationSerif-Regular.ttf",
+    "/usr/share/fonts/truetype/dejavu/DejaVuSerif.ttf",
+    "/usr/share/fonts/truetype/freefont/FreeSerif.ttf",
+]
+
+
+def _try_font(paths: list[str], size: int) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    for p in paths:
+        try:
+            return ImageFont.truetype(p, size)
+        except Exception:
+            continue
+    return ImageFont.load_default()
+
+
+def render_newspaper_image(headline: str, article: str, day_number: int) -> str:
+    """Render the front page as a PNG and return the file path."""
+    W, H = 920, 680
+    PAPER   = (245, 232, 200)   # old paper cream
+    INK     = (22,  10,  4)     # near-black
+    BORDER  = (72,  42,  10)    # dark brown
+    SUBINK  = (88,  56,  28)
+
+    img  = Image.new("RGB", (W, H), PAPER)
+    draw = ImageDraw.Draw(img)
+
+    f_mast  = _try_font(_SERIF_BOLD,  30)
+    f_hed   = _try_font(_SERIF_BOLD,  22)
+    f_body  = _try_font(_SERIF_REG,   13)
+    f_small = _try_font(_SERIF_REG,   10)
+
+    M = 18   # margin
+
+    # ── Double border ────────────────────────────────────────────
+    draw.rectangle([M, M, W-M, H-M], outline=BORDER, width=3)
+    draw.rectangle([M+6, M+6, W-M-6, H-M-6], outline=BORDER, width=1)
+
+    y = M + 16
+
+    # ── Masthead ─────────────────────────────────────────────────
+    MAST = "THE TINYWICK HOLLOW GAZETTE"
+    bb   = draw.textbbox((0, 0), MAST, font=f_mast)
+    tw   = bb[2] - bb[0]
+    draw.text(((W - tw) / 2, y), MAST, fill=INK, font=f_mast)
+    y += bb[3] - bb[1] + 4
+
+    sub = f"Est. Day 1   *   Day {day_number}   *   One Acorn Per Copy   *   For All Woodland Readers"
+    bb  = draw.textbbox((0, 0), sub, font=f_small)
+    draw.text(((W - bb[2]) / 2, y), sub, fill=SUBINK, font=f_small)
+    y += bb[3] - bb[1] + 6
+
+    # Rule (double)
+    draw.line([M+10, y, W-M-10, y], fill=BORDER, width=2)
+    draw.line([M+10, y+5, W-M-10, y+5], fill=BORDER, width=1)
+    y += 18
+
+    # ── Headline (wrapped, centred) ───────────────────────────────
+    for line in textwrap.wrap(headline, width=52):
+        bb = draw.textbbox((0, 0), line, font=f_hed)
+        draw.text(((W - (bb[2] - bb[0])) / 2, y), line, fill=INK, font=f_hed)
+        y += bb[3] - bb[1] + 2
+    y += 4
+
+    draw.line([M+10, y, W-M-10, y], fill=BORDER, width=1)
+    y += 12
+
+    # ── Two-column article ────────────────────────────────────────
+    PAD     = M + 14
+    COL_GAP = 28
+    col_w   = (W - 2*PAD - COL_GAP) // 2
+    col1_x  = PAD
+    col2_x  = PAD + col_w + COL_GAP
+    LINE_H  = 16
+
+    wrapped = textwrap.wrap(article, width=46)
+    mid     = max(1, len(wrapped) // 2)
+    max_y   = H - M - 40
+
+    ly = y
+    for line in wrapped[:mid]:
+        if ly + LINE_H > max_y:
+            break
+        draw.text((col1_x, ly), line, fill=INK, font=f_body)
+        ly += LINE_H
+
+    div_x = col1_x + col_w + COL_GAP // 2
+    draw.line([div_x, y, div_x, min(ly, max_y)], fill=SUBINK, width=1)
+
+    ry = y
+    for line in wrapped[mid:]:
+        if ry + LINE_H > max_y:
+            break
+        draw.text((col2_x, ry), line, fill=INK, font=f_body)
+        ry += LINE_H
+
+    # ── Footer ────────────────────────────────────────────────────
+    fy = H - M - 28
+    draw.line([M+10, fy, W-M-10, fy], fill=BORDER, width=1)
+    footer = (f"Fox  -  Badger  -  Squirrel  -  Mole  "
+              f"|  (c) The Tinywick Hollow Gazette, Day {day_number}")
+    bb = draw.textbbox((0, 0), footer, font=f_small)
+    draw.text(((W - (bb[2] - bb[0])) / 2, fy + 6), footer, fill=SUBINK, font=f_small)
+
+    path = f"/tmp/tinywick_day_{day_number}.png"
+    img.save(path, "PNG")
+    return path
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 7 ▸ CSS
+# ═══════════════════════════════════════════════════════════════════
+NEWSPAPER_CSS = r"""
+/* ── Google Fonts ── */
+@import url('https://fonts.googleapis.com/css2?family=Playfair+Display:ital,wght@0,400;0,700;0,900;1,400&family=Libre+Baskerville:ital,wght@0,400;0,700;1,400&family=UnifrakturMaguntia&display=swap');
+
+/* ── Page background ── */
+body, .gradio-container {
+    background: #c9b89a !important;
+    font-family: 'Libre Baskerville', Georgia, serif !important;
+}
+
+/* ── Newspaper wrapper ── */
+.paper-wrap {
+    background: #f4e9d2;
+    background-image:
+        linear-gradient(rgba(160,120,70,.06) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(160,120,70,.04) 1px, transparent 1px);
+    background-size: 100% 22px, 80px 100%;
+    border: 3px solid #4a2c0a;
+    border-radius: 2px;
+    padding: 22px 28px 18px;
+    box-shadow: 5px 5px 24px rgba(0,0,0,.32),
+                inset 0 0 80px rgba(180,140,90,.18);
+    margin: 8px 0;
+    position: relative;
+}
+.paper-wrap::before, .paper-wrap::after {
+    content: "";
+    display: block;
+    border: 1px solid #4a2c0a;
+    position: absolute;
+    pointer-events: none;
+}
+.paper-wrap::before { inset: 7px; }
+
+/* ── Masthead ── */
+.paper-masthead {
+    font-family: 'UnifrakturMaguntia', 'Playfair Display', Georgia, serif;
+    font-size: 2.3em;
+    text-align: center;
+    color: #1a0a04;
+    border-top: 4px double #4a2c0a;
+    border-bottom: 4px double #4a2c0a;
+    padding: 6px 0;
+    margin-bottom: 4px;
+    letter-spacing: 1px;
+}
+.paper-sub {
+    font-family: 'Libre Baskerville', Georgia, serif;
+    font-size: 0.73em;
+    color: #5a3820;
+    text-align: center;
+    font-style: italic;
+    margin-bottom: 10px;
+}
+.paper-rule {
+    border: none;
+    border-top: 2px solid #4a2c0a;
+    margin: 2px 0 8px;
+}
+.paper-rule-thin {
+    border: none;
+    border-top: 1px solid #8a6040;
+    margin: 4px 0;
+}
+
+/* ── Headline ── */
+.paper-headline {
+    font-family: 'Playfair Display', Georgia, serif;
+    font-size: 1.75em;
+    font-weight: 900;
+    text-align: center;
+    text-transform: uppercase;
+    color: #0d0602;
+    line-height: 1.15;
+    margin: 8px 0 10px;
+}
+
+/* ── Article body (two-column feel via CSS) ── */
+.paper-article {
+    font-family: 'Libre Baskerville', Georgia, serif;
+    font-size: 0.9em;
+    color: #1a0c06;
+    line-height: 1.72;
+    text-align: justify;
+    column-count: 2;
+    column-gap: 28px;
+    column-rule: 1px solid #9a7050;
+    padding: 6px 4px 0;
+}
+
+/* ── Day badge ── */
+.paper-daybadge {
+    font-family: 'Libre Baskerville', Georgia, serif;
+    font-size: 0.78em;
+    color: #5a3820;
+    text-align: center;
+    border-top: 1px solid #9a7050;
+    margin-top: 10px;
+    padding-top: 6px;
+}
+
+/* ── Status bar ── */
+.status-strip {
+    background: #d6c4a2;
+    border: 1px solid #8a6040;
+    border-radius: 3px;
+    padding: 6px 14px;
+    font-family: 'Libre Baskerville', Georgia, serif;
+    font-size: 0.83em;
+    color: #2c1810;
+    text-align: center;
+    margin: 4px 0;
+}
+
+/* ── Creature cards ── */
+.creature-card {
+    background: #f7eed8;
+    border: 1px solid #9a7050;
+    border-radius: 3px;
+    padding: 9px 12px;
+    font-family: 'Libre Baskerville', Georgia, serif;
+    font-size: 0.82em;
+    color: #1c0e08;
+    flex: 1;
+    min-width: 160px;
+}
+.creature-name {
+    font-weight: 700;
+    font-size: 1em;
+    color: #2c1008;
+    display: block;
+    margin-bottom: 3px;
+}
+
+/* ── Section titles ── */
+.section-title {
+    font-family: 'Playfair Display', Georgia, serif;
+    font-weight: 700;
+    color: #2c1008;
+    font-size: 1em;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    text-align: center;
+    border-bottom: 1px solid #8a6040;
+    padding-bottom: 4px;
+    margin: 8px 0 10px;
+}
+
+/* ── Archive display area ── */
+.archive-area {
+    background: #f0e4c8;
+    border: 1px solid #9a7050;
+    border-radius: 3px;
+    padding: 10px;
+    margin-top: 6px;
+    min-height: 60px;
+}
+
+/* ── Buttons ── */
+button.lg { font-family: 'Libre Baskerville', Georgia, serif !important; }
+
+/* ── Konami modal ── */
+#konami-modal {
+    display: none;
+    position: fixed;
+    z-index: 99999;
+    top: 50%; left: 50%;
+    transform: translate(-50%, -50%);
+    width: min(640px, 92vw);
+    max-height: 78vh;
+    overflow-y: auto;
+    background: #f4e9d2;
+    border: 3px solid #4a2c0a;
+    box-shadow: 8px 8px 36px rgba(0,0,0,.55);
+    padding: 24px 28px 20px;
+    font-family: 'Libre Baskerville', Georgia, serif;
+}
+#konami-modal h2 {
+    font-family: 'Playfair Display', Georgia, serif;
+    color: #1a0a04;
+    margin-top: 0;
+}
+#konami-modal details { margin: 8px 0; }
+#konami-modal summary {
+    cursor: pointer;
+    font-weight: 700;
+    color: #4a2c0a;
+}
+#konami-modal pre {
+    background: #e8d8b8;
+    border: 1px solid #9a7050;
+    padding: 10px;
+    font-size: 0.78em;
+    white-space: pre-wrap;
+    word-break: break-word;
+    border-radius: 3px;
+    margin: 6px 0 0;
+}
+#konami-close {
+    position: absolute;
+    top: 10px; right: 14px;
+    cursor: pointer;
+    font-size: 1.4em;
+    color: #4a2c0a;
+    background: none;
+    border: none;
+    font-family: serif;
+}
+#konami-backdrop {
+    display: none;
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,.45);
+    z-index: 99998;
+}
+"""
+
+# ═══════════════════════════════════════════════════════════════════
+# 8 ▸ JAVASCRIPT
+# ═══════════════════════════════════════════════════════════════════
+KONAMI_JS = r"""
+<script>
+(function() {
+  var SEQ = ['ArrowUp','ArrowUp','ArrowDown','ArrowDown',
+             'ArrowLeft','ArrowRight','ArrowLeft','ArrowRight','b','a'];
+  var idx = 0;
+
+  document.addEventListener('keydown', function(e) {
+    if (e.key === SEQ[idx]) {
+      idx++;
+      if (idx === SEQ.length) { idx = 0; showKonami(); }
+    } else {
+      idx = (e.key === SEQ[0]) ? 1 : 0;
+    }
+  });
+
+  window.showKonami = function() {
+    document.getElementById('konami-backdrop').style.display = 'block';
+    document.getElementById('konami-modal').style.display   = 'block';
+  };
+  window.hideKonami = function() {
+    document.getElementById('konami-backdrop').style.display = 'none';
+    document.getElementById('konami-modal').style.display   = 'none';
+  };
+})();
+</script>
+"""
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 9 ▸ HTML FORMATTERS
+# ═══════════════════════════════════════════════════════════════════
+
+def _html_paper(headline: str, article: str, day_num: int) -> str:
+    escaped_hed  = headline.replace("<", "&lt;").replace(">", "&gt;")
+    escaped_body = article.replace("<", "&lt;").replace(">", "&gt;")
+    emojis = "  ".join(f"{CREATURE_EMOJI[c]} {c.capitalize()}" for c in CREATURES)
+    return f"""
+<div class="paper-wrap">
+  <div class="paper-masthead">The Tinywick Hollow Gazette</div>
+  <div class="paper-sub">Est. Day&nbsp;1 &nbsp;✦&nbsp; Day&nbsp;{day_num}
+       &nbsp;✦&nbsp; One Acorn Per Copy &nbsp;✦&nbsp; Serving the Woodland Community</div>
+  <hr class="paper-rule">
+  <div class="paper-headline">{escaped_hed}</div>
+  <hr class="paper-rule-thin">
+  <div class="paper-article">{escaped_body}</div>
+  <div class="paper-daybadge">— Day {day_num} — &nbsp;&nbsp; {emojis}</div>
+</div>
+"""
+
+
+def _html_placeholder() -> str:
+    return """
+<div class="paper-wrap">
+  <div class="paper-masthead">The Tinywick Hollow Gazette</div>
+  <div class="paper-sub">Est. Day 1 &nbsp;✦&nbsp; One Acorn Per Copy</div>
+  <hr class="paper-rule">
+  <div class="paper-headline">AWAITING FIRST LIGHT IN TINYWICK HOLLOW</div>
+  <hr class="paper-rule-thin">
+  <div class="paper-article">
+    The hollow is still. Reginald Fox has not yet stirred from his den.
+    Beatrice Badger has not yet issued any proclamations. Cornelius Squirrel
+    has not yet invented anything that almost works. Millicent Mole has not yet
+    surfaced with an oblique observation. Press <em>Advance Day</em> to begin
+    the chronicle of this peculiar civilisation.
+  </div>
+  <div class="paper-daybadge">— Day 0 — &nbsp; Awaiting commencement</div>
+</div>
+"""
+
+
+def _html_creatures() -> str:
+    creatures = database.get_all_creatures()
+    cards = ""
+    for c in creatures:
+        emoji = CREATURE_EMOJI.get(c["name"], "?")
+        rel   = ", ".join(
+            f"{k}: {v}" for k, v in sorted(c["relationship_scores"].items())
+        )
+        inv = (", ".join(c["inventory"][:3]) + ("…" if len(c["inventory"]) > 3 else "")) \
+              or "nothing"
+        cards += f"""
+<div class="creature-card">
+  <span class="creature-name">{emoji} {c['name'].capitalize()}</span>
+  <em>Carries:</em> {inv}<br>
+  <small><em>Relations:</em> {rel}</small>
+</div>
+"""
+    return f'<div style="display:flex;gap:8px;flex-wrap:wrap;">{cards}</div>'
+
+
+def _archive_choices() -> list[tuple[str, int]]:
+    headlines = database.get_all_headlines()
+    if not headlines:
+        return []
+    return [
+        (f"Day {dn}: {h[:45]}{'…' if len(h)>45 else ''}", dn)
+        for dn, h in headlines
+    ]
+
+
+def _status(msg: str) -> str:
+    return f'<div class="status-strip">{msg}</div>'
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 10 ▸ GRADIO EVENT HANDLERS
+# ═══════════════════════════════════════════════════════════════════
+
+def _update_all(
+    day_num: int, headline: str, article: str, status_msg: str
+) -> tuple:
+    """Return values for all shared outputs."""
+    return (
+        _html_paper(headline, article, day_num),   # newspaper_display
+        _html_creatures(),                          # creature_display
+        gr.update(choices=_archive_choices(), value=None),  # archive_dd
+        _status(status_msg),                        # status_html
+        day_num,                                    # day_state
+        headline,                                   # hed_state
+        article,                                    # art_state
+    )
+
+
+def handle_advance() -> tuple:
+    try:
+        dn, hed, art = advance_day()
+        return _update_all(dn, hed, art, f"✓ Day {dn} published to the Gazette.")
+    except Exception:
+        tb = traceback.format_exc()
+        print(tb)
+        return _update_all(0, "PRESS ERROR", tb[:300], "✗ Simulation error — check logs.")
+
+
+def handle_rumour(creature: str, rumour: str) -> tuple:
+    try:
+        dn, hed, art = advance_day("rumour", rumour, creature)
+        msg = f"✓ Day {dn}: Rumour about {creature} has spread through the hollow."
+        return _update_all(dn, hed, art, msg)
+    except Exception:
+        print(traceback.format_exc())
+        return _update_all(0, "RUMOUR SUPPRESSED", "The rumour never left the burrow.", "✗ Error.")
+
+
+def handle_donation(obj: str) -> tuple:
+    try:
+        dn, hed, art = advance_day("donation", obj, None)
+        msg = f"✓ Day {dn}: '{obj}' has been donated — someone is now confused."
+        return _update_all(dn, hed, art, msg)
+    except Exception:
+        print(traceback.format_exc())
+        return _update_all(0, "DONATION LOST", "The object was never found.", "✗ Error.")
+
+
+def handle_law(law: str) -> tuple:
+    try:
+        dn, hed, art = advance_day("law", law, None)
+        msg = f"✓ Day {dn}: New law proposed — '{law}'. Compliance uncertain."
+        return _update_all(dn, hed, art, msg)
+    except Exception:
+        print(traceback.format_exc())
+        return _update_all(0, "LAW STRUCK DOWN", "The proposal was eaten by a mole.", "✗ Error.")
+
+
+def handle_archive_view(day_num: int | None) -> str:
+    if day_num is None:
+        return '<div class="archive-area"><em>Select a day above to view its front page.</em></div>'
+    day = database.get_day(int(day_num))
+    if not day:
+        return '<div class="archive-area"><em>Day not found in the archive.</em></div>'
+    text  = day["full_newspaper_text"]
+    parts = text.split("\n\n", 1)
+    hed   = parts[0] if parts else "UNKNOWN"
+    art   = parts[1] if len(parts) > 1 else text
+    return f'<div class="archive-area">{_html_paper(hed, art, day_num)}</div>'
+
+
+def handle_share(day_num: int, headline: str, article: str):
+    if day_num == 0 or not headline:
+        return gr.update(visible=False, value=None)
+    try:
+        path = render_newspaper_image(headline, article, day_num)
+        return gr.update(visible=True, value=path)
+    except Exception:
+        print(traceback.format_exc())
+        return gr.update(visible=False, value=None)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 11 ▸ BUILD KONAMI MODAL HTML
+# ��══════════════════════════════════════════════════════════════════
+def _konami_modal_html() -> str:
+    import html as _html
+    details = ""
+    for name, prompt in AGENT_PROMPTS.items():
+        emoji = CREATURE_EMOJI.get(name, "")
+        esc   = _html.escape(prompt)
+        details += f"""
+<details>
+  <summary>{emoji} <strong>{name.upper()}</strong></summary>
+  <pre>{esc}</pre>
+</details>"""
+    esc_narrator = _html.escape(NARRATOR_PROMPT)
+    details += f"""
+<details>
+  <summary>📰 <strong>NARRATOR (Gazette Editor)</strong></summary>
+  <pre>{esc_narrator}</pre>
+</details>"""
+    return f"""
+<div id="konami-backdrop" onclick="hideKonami()"></div>
+<div id="konami-modal" role="dialog" aria-modal="true">
+  <button id="konami-close" onclick="hideKonami()" title="Close">✕</button>
+  <h2>🔮 Secret Agent Briefing</h2>
+  <p>You found the Konami Code Easter Egg! Here are the raw system prompts
+     that drive our woodland correspondents and the Gazette editor:</p>
+  {details}
+  <hr style="border-color:#9a7050;margin:16px 0 10px;">
+  <p style="text-align:center;font-style:italic;color:#5a3820;font-size:.85em;">
+    ↑↑↓↓←→←→BA — only the woodland elite know this. 🎮
+  </p>
+</div>
+{KONAMI_JS}
+"""
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 12 ▸ GRADIO BLOCKS APP
+# ═══════════════════════════════════════════════════════════════════
+
+# ── Gradio 6+ moved css/theme from Blocks() to launch() ──────────
+_GR_MAJOR = int(gr.__version__.split(".")[0])
+if _GR_MAJOR >= 6:
+    _BLOCKS_KW: dict = {}
+    _LAUNCH_KW: dict = {"css": NEWSPAPER_CSS}
+else:
+    _BLOCKS_KW = {
+        "css": NEWSPAPER_CSS,
+        "theme": gr.themes.Base(
+            primary_hue=gr.themes.colors.orange,
+            neutral_hue=gr.themes.colors.stone,
+        ),
+    }
+    _LAUNCH_KW = {}
+
+# Initialise DB and read starting state
+database.init_db()
+_latest = database.get_latest_day()
+if _latest:
+    _parts    = _latest["full_newspaper_text"].split("\n\n", 1)
+    _INIT_DAY = _latest["day_number"]
+    _INIT_HED = _parts[0]
+    _INIT_ART = _parts[1] if len(_parts) > 1 else _latest["full_newspaper_text"]
+else:
+    _INIT_DAY = 0
+    _INIT_HED = ""
+    _INIT_ART = ""
+
+# Shared output definition (returned by every nudge/advance handler)
+_COMMON = 7   # newspaper, creatures, archive_dd, status, day_state, hed_state, art_state
+
+with gr.Blocks(
+    title="Tiny Civilization — The Tinywick Hollow Gazette",
+    **_BLOCKS_KW,
+) as demo:
+
+    # ── Konami modal (injected before everything else) ───────────
+    gr.HTML(_konami_modal_html())
+
+    # ── Page header ──────────────────────────────────────────────
+    gr.HTML("""
+<div style="text-align:center;padding:8px 0 4px;">
+  <h1 style="font-family:'Playfair Display',Georgia,serif;color:#1a0a04;
+             font-size:1.8em;margin:0 0 2px;">
+    🦊 Tiny Civilization 🐀
+  </h1>
+  <p style="font-family:Georgia,serif;color:#5a3820;font-style:italic;
+            margin:0;font-size:.88em;">
+    A persistent woodland civilisation. One day at a time. One acorn at a time.
+    &nbsp;|&nbsp; <kbd title="Konami Code">↑↑↓↓←→←→BA</kbd> for secrets.
+  </p>
+</div>
+""")
+
+    # ── Persistent state ─────────────────────────────────────────
+    day_state = gr.State(_INIT_DAY)
+    hed_state = gr.State(_INIT_HED)
+    art_state = gr.State(_INIT_ART)
+
+    # ── Status bar ───────────────────────────────────────────────
+    status_html = gr.HTML(
+        value=_status(
+            f"Day {_INIT_DAY} already in the archive — ready for Day {_INIT_DAY+1}."
+            if _INIT_DAY > 0 else
+            "No days recorded yet. Click Advance Day to start the chronicle."
+        )
+    )
+
+    # ── Main layout ──────────────────────────────────────────────
+    with gr.Row(equal_height=False):
+
+        # ── LEFT: Newspaper display ──────────────────────────────
+        with gr.Column(scale=3):
+            newspaper_display = gr.HTML(
+                value=_html_paper(_INIT_HED, _INIT_ART, _INIT_DAY)
+                      if _INIT_DAY > 0 else _html_placeholder()
+            )
+
+            # Archive
+            with gr.Accordion("📜 Archive — Past Front Pages", open=False):
+                archive_dd = gr.Dropdown(
+                    choices=_archive_choices(),
+                    value=None,
+                    label="Select a past day",
+                    container=False,
+                )
+                archive_display = gr.HTML(
+                    value='<div class="archive-area">'
+                          '<em>Select a day above to view its edition.</em></div>'
+                )
+
+        # ── RIGHT: Controls ──────────────────────────────────────
+        with gr.Column(scale=1, min_width=240):
+
+            gr.HTML('<div class="section-title">📰 Editorial Desk</div>')
+
+            advance_btn = gr.Button(
+                "📅 Advance Day  (no nudge)",
+                variant="primary",
+                size="lg",
+            )
+
+            gr.HTML('<hr style="border-color:#9a7050;margin:10px 0;">')
+            gr.HTML('<div class="section-title">✉ Nudge the Story</div>')
+            gr.HTML('<p style="font-size:.8em;color:#5a3820;text-align:center;'
+                    'font-style:italic;margin:0 0 8px;">Each nudge advances the day.</p>')
+
+            # Nudge 1 — Rumour
+            with gr.Accordion("🗣️ Spread a Rumour", open=False):
+                rumour_creature = gr.Dropdown(
+                    choices=CREATURES,
+                    value=CREATURES[0],
+                    label="About which creature?",
+                )
+                rumour_type_dd = gr.Dropdown(
+                    choices=RUMOUR_TYPES,
+                    value=RUMOUR_TYPES[0],
+                    label="What kind of rumour?",
+                )
+                rumour_btn = gr.Button("📢 Spread It", variant="secondary")
+
+            # Nudge 2 — Donation
+            with gr.Accordion("🎁 Donate a Weird Object", open=False):
+                donation_dd = gr.Dropdown(
+                    choices=WEIRD_OBJECTS,
+                    value=WEIRD_OBJECTS[0],
+                    label="Which object?",
+                )
+                donation_btn = gr.Button("🎁 Donate It", variant="secondary")
+
+            # Nudge 3 — Law
+            with gr.Accordion("⚖️ Propose a New Law", open=False):
+                law_dd = gr.Dropdown(
+                    choices=LAWS,
+                    value=LAWS[0],
+                    label="Which law?",
+                )
+                law_btn = gr.Button("⚖️ Propose It", variant="secondary")
+
+            gr.HTML('<hr style="border-color:#9a7050;margin:10px 0;">')
+
+            share_btn   = gr.Button("🖼️ Share as Image", variant="secondary")
+            img_output  = gr.Image(
+                label="Front Page PNG",
+                visible=False,
+                type="filepath",
+            )
+
+            gr.HTML(
+                '<p style="font-size:.72em;color:#6a4828;text-align:center;'
+                'margin-top:8px;font-style:italic;">'
+                'Model: Qwen2.5-7B (or 3B fallback)<br>'
+                'Powered by ZeroGPU · Tiny Civilization</p>'
+            )
+
+    # ── Creature status ──────────────────────────────────────────
+    gr.HTML('<div class="section-title" style="margin-top:14px;">Woodland Residents</div>')
+    creature_display = gr.HTML(value=_html_creatures())
+
+    # ── Wire outputs list ─────────────────────────────────────────
+    _OUTPUTS = [
+        newspaper_display,
+        creature_display,
+        archive_dd,
+        status_html,
+        day_state,
+        hed_state,
+        art_state,
+    ]
+
+    # ── Event wiring ─────────────────────────────────────────────
+    advance_btn.click(fn=handle_advance, inputs=[], outputs=_OUTPUTS)
+
+    rumour_btn.click(
+        fn=handle_rumour,
+        inputs=[rumour_creature, rumour_type_dd],
+        outputs=_OUTPUTS,
+    )
+
+    donation_btn.click(
+        fn=handle_donation,
+        inputs=[donation_dd],
+        outputs=_OUTPUTS,
+    )
+
+    law_btn.click(
+        fn=handle_law,
+        inputs=[law_dd],
+        outputs=_OUTPUTS,
+    )
+
+    archive_dd.change(
+        fn=handle_archive_view,
+        inputs=[archive_dd],
+        outputs=[archive_display],
+    )
+
+    share_btn.click(
+        fn=handle_share,
+        inputs=[day_state, hed_state, art_state],
+        outputs=[img_output],
+    )
+
+
+# ═══════════════════════════════════════════════════════════════════
+# 13 ▸ ENTRY POINT
+# ══════════════════════════════════════════════��════════════════════
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, **_LAUNCH_KW)

database.py

@@ -0,0 +1,260 @@
+"""
+database.py — Tiny Civilization persistent storage layer.
+All simulation state lives in a SQLite file. Functions are designed to be
+safe for concurrent Gradio calls (each call opens its own short-lived connection).
+"""
+
+import sqlite3
+import json
+import os
+from datetime import datetime
+from typing import Optional
+
+# ──────────────────────────────────────────────────────────────
+# Database path — prefer HF Spaces /data (persistent volume),
+# then fall back gracefully to a local file.
+# ──────────────────────────────────────────────────────────────
+_DATA_DIRS = ["/data", "."]
+DB_PATH = os.getenv("TINY_DB_PATH", "")
+if not DB_PATH:
+    for _d in _DATA_DIRS:
+        try:
+            os.makedirs(_d, exist_ok=True)
+            _test = os.path.join(_d, ".write_test")
+            with open(_test, "w") as f:
+                f.write("ok")
+            os.remove(_test)
+            DB_PATH = os.path.join(_d, "tiny_civilization.db")
+            break
+        except Exception:
+            continue
+    if not DB_PATH:
+        DB_PATH = "tiny_civilization.db"
+
+
+def _conn() -> sqlite3.Connection:
+    """Open a SQLite connection with row_factory for dict-style access."""
+    c = sqlite3.connect(DB_PATH, check_same_thread=False, timeout=10)
+    c.row_factory = sqlite3.Row
+    return c
+
+
+# ──────────────────────────────────────────────────────────────
+# Schema
+# ──────────────────────────────────────────────────────────────
+
+def init_db() -> None:
+    """Create tables and seed starting creature state if absent."""
+    with _conn() as con:
+        cur = con.cursor()
+
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS days (
+                day_number        INTEGER PRIMARY KEY,
+                headline          TEXT    NOT NULL,
+                full_newspaper_text TEXT  NOT NULL,
+                timestamp         TEXT    NOT NULL
+            )
+        """)
+
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS events (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                day_number  INTEGER NOT NULL,
+                actor       TEXT    NOT NULL,
+                action      TEXT    NOT NULL,
+                target      TEXT    NOT NULL,
+                description TEXT    NOT NULL
+            )
+        """)
+
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS creatures (
+                name                TEXT PRIMARY KEY,
+                relationship_scores TEXT NOT NULL DEFAULT '{}',
+                inventory           TEXT NOT NULL DEFAULT '[]'
+            )
+        """)
+
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS nudges (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                day_number  INTEGER NOT NULL,
+                nudge_type  TEXT    NOT NULL,
+                nudge_value TEXT    NOT NULL
+            )
+        """)
+
+        con.commit()
+
+        # ── Seed creatures if the table is empty ──────────────
+        _SEED = {
+            "fox": {
+                "relationships": {"badger": 42, "squirrel": 61, "mole": 55},
+                "inventory": ["forged certificate of merit", "silk scarf (suspect origin)"],
+            },
+            "badger": {
+                "relationships": {"fox": 28, "squirrel": 67, "mole": 72},
+                "inventory": ["ancient grudge (well-preserved)", "favourite grey stone"],
+            },
+            "squirrel": {
+                "relationships": {"fox": 63, "badger": 70, "mole": 48},
+                "inventory": ["seven-and-a-half acorns", "borrowed umbrella (decade old)"],
+            },
+            "mole": {
+                "relationships": {"fox": 51, "badger": 76, "squirrel": 53},
+                "inventory": ["map of secret tunnels", "crystal monocle", "lost button"],
+            },
+        }
+
+        for name, data in _SEED.items():
+            exists = cur.execute(
+                "SELECT 1 FROM creatures WHERE name = ?", (name,)
+            ).fetchone()
+            if not exists:
+                cur.execute(
+                    "INSERT INTO creatures (name, relationship_scores, inventory) VALUES (?,?,?)",
+                    (name, json.dumps(data["relationships"]), json.dumps(data["inventory"])),
+                )
+
+        con.commit()
+
+
+# ──────────────────────────────────────────────────────────────
+# Days
+# ──────────────────────────────────────────────────────────────
+
+def save_day(day_number: int, headline: str, full_newspaper_text: str) -> None:
+    with _conn() as con:
+        con.execute(
+            "INSERT OR REPLACE INTO days (day_number, headline, full_newspaper_text, timestamp) "
+            "VALUES (?,?,?,?)",
+            (day_number, headline, full_newspaper_text, datetime.now().isoformat()),
+        )
+        con.commit()
+
+
+def get_latest_day() -> Optional[dict]:
+    with _conn() as con:
+        row = con.execute(
+            "SELECT * FROM days ORDER BY day_number DESC LIMIT 1"
+        ).fetchone()
+    return dict(row) if row else None
+
+
+def get_day(day_number: int) -> Optional[dict]:
+    with _conn() as con:
+        row = con.execute(
+            "SELECT * FROM days WHERE day_number = ?", (day_number,)
+        ).fetchone()
+    return dict(row) if row else None
+
+
+def get_all_headlines() -> list[tuple[int, str]]:
+    with _conn() as con:
+        rows = con.execute(
+            "SELECT day_number, headline FROM days ORDER BY day_number DESC"
+        ).fetchall()
+    return [(r["day_number"], r["headline"]) for r in rows]
+
+
+def get_next_day_number() -> int:
+    with _conn() as con:
+        row = con.execute("SELECT MAX(day_number) AS m FROM days").fetchone()
+    return (row["m"] or 0) + 1
+
+
+# ──────────────────────────────────────────────────────────────
+# Events
+# ──────────────────────────────────────────────────────────────
+
+def save_event(
+    day_number: int, actor: str, action: str, target: str, description: str
+) -> None:
+    with _conn() as con:
+        con.execute(
+            "INSERT INTO events (day_number, actor, action, target, description) "
+            "VALUES (?,?,?,?,?)",
+            (day_number, actor, action, target, description),
+        )
+        con.commit()
+
+
+def get_events_for_day(day_number: int) -> list[dict]:
+    with _conn() as con:
+        rows = con.execute(
+            "SELECT actor, action, target, description FROM events WHERE day_number = ?",
+            (day_number,),
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+# ──────────────────────────────────────────────────────────────
+# Nudges
+# ──────────────────────────────────────────────────────────────
+
+def save_nudge(day_number: int, nudge_type: str, nudge_value: str) -> None:
+    with _conn() as con:
+        con.execute(
+            "INSERT INTO nudges (day_number, nudge_type, nudge_value) VALUES (?,?,?)",
+            (day_number, nudge_type, nudge_value),
+        )
+        con.commit()
+
+
+def get_recent_nudges(limit: int = 4) -> list[dict]:
+    with _conn() as con:
+        rows = con.execute(
+            "SELECT day_number, nudge_type, nudge_value FROM nudges ORDER BY id DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+# ──────────────────────────────────────────────────────────────
+# Creatures
+# ──────────────────────────────────────────────────────────────
+
+def _parse_creature(row: sqlite3.Row) -> dict:
+    d = dict(row)
+    d["relationship_scores"] = json.loads(d["relationship_scores"])
+    d["inventory"] = json.loads(d["inventory"])
+    return d
+
+
+def get_creature(name: str) -> Optional[dict]:
+    with _conn() as con:
+        row = con.execute(
+            "SELECT * FROM creatures WHERE name = ?", (name,)
+        ).fetchone()
+    return _parse_creature(row) if row else None
+
+
+def get_all_creatures() -> list[dict]:
+    with _conn() as con:
+        rows = con.execute("SELECT * FROM creatures").fetchall()
+    return [_parse_creature(r) for r in rows]
+
+
+def update_creature(
+    name: str,
+    relationship_scores: Optional[dict] = None,
+    inventory: Optional[list] = None,
+) -> None:
+    with _conn() as con:
+        if relationship_scores is not None and inventory is not None:
+            con.execute(
+                "UPDATE creatures SET relationship_scores=?, inventory=? WHERE name=?",
+                (json.dumps(relationship_scores), json.dumps(inventory), name),
+            )
+        elif relationship_scores is not None:
+            con.execute(
+                "UPDATE creatures SET relationship_scores=? WHERE name=?",
+                (json.dumps(relationship_scores), name),
+            )
+        elif inventory is not None:
+            con.execute(
+                "UPDATE creatures SET inventory=? WHERE name=?",
+                (json.dumps(inventory), name),
+            )
+        con.commit()

packages.txt

@@ -0,0 +1,2 @@
+fonts-liberation
+fonts-dejavu-core

requirements.txt

@@ -0,0 +1,19 @@
+# ── Tiny Civilization — requirements.txt ──────────────────────────
+# Hugging Face Build Small Hackathon / Thousand Token Wood track
+
+# Core inference
+torch>=2.1.0
+transformers>=4.44.0
+accelerate>=0.30.0        # device_map="auto" multi-device support
+
+# HF Spaces GPU management
+spaces>=0.19.0            # ZeroGPU @spaces.GPU decorator
+
+# UI
+gradio>=4.40.0
+
+# Image generation (newspaper PNG)
+Pillow>=10.3.0
+
+# Utilities (already in most Python envs, listed for explicitness)
+# sqlite3  — stdlib, no install needed