final

.dockerignore

@@ -5,6 +5,5 @@
 .gitignore
 __pycache__/
 *.pyc
-dashboard/
 mcp-aiven/
 *.md

Dockerfile

@@ -1,25 +1,21 @@
-# Murmur fleet — long-running worker that runs coordination rounds through the Aiven MCP.
-# No direct DB/Kafka drivers: it's an MCP client (mcp) + claude-sonnet (anthropic) + local
-# embeddings (fastembed). Secrets are injected at deploy time, never baked into the image.
+# Murmur — ONE container that runs the agent swarm (conductor) + the live dashboard.
+# Deploys anywhere that builds a Dockerfile; tuned for Hugging Face Spaces (Docker SDK, port 7860).
+# The public URL is the live wall; the agents run inside, talking to Aiven entirely via the MCP.
+# Secrets (ANTHROPIC_API_KEY, AIVEN_TOKEN, DATABASE_URL) are injected at runtime — never baked in.
 FROM python:3.11-slim
 
 WORKDIR /app
-
-# Python deps.
-RUN pip install --no-cache-dir "mcp>=1.0" "anthropic>=0.40" "fastembed>=0.4"
-
-# Bake the embedding model into the image so the worker never downloads it at runtime.
-RUN python -c "from fastembed import TextEmbedding; TextEmbedding('BAAI/bge-small-en-v1.5')"
+RUN pip install --no-cache-dir "mcp>=1.0" "anthropic>=0.40" "fastembed>=0.4" \
+    "flask>=3.0" "psycopg[binary]>=3.1" "python-dotenv>=1.0"
 
 COPY murmur.py .
+COPY dashboard/ dashboard/
 
-# Aiven Apps requires a listening port; the worker serves a status endpoint here and runs
-# coordination rounds in the background.
-ENV PORT=8080 \
-    MURMUR_SERVE=1 \
-    MURMUR_FLEET=6 \
-    MURMUR_INTERVAL=300
-EXPOSE 8080
+# HF Spaces serves the port declared as app_port (7860). The dashboard binds it publicly;
+# the conductor keeps its own status endpoint on 8080 (internal).
+ENV HOST=0.0.0.0 FLASK_DEBUG=0 MURMUR_FLEET=6 MURMUR_INTERVAL=180 \
+    HOME=/tmp PYTHONUNBUFFERED=1
+EXPOSE 7860
 
-# ANTHROPIC_API_KEY and AIVEN_TOKEN are injected as secrets at deploy time — never baked in.
-CMD ["python", "murmur.py", "--serve"]
+# agents (conductor) in the background + the public dashboard in the foreground
+CMD ["bash","-lc","PORT=8080 python murmur.py --serve & exec env PORT=7860 python dashboard/app.py"]

README.md

@@ -0,0 +1,46 @@
+---
+title: Murmur
+emoji: 🐦
+colorFrom: indigo
+colorTo: pink
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# Murmur — a self-coordinating agent swarm on Aiven
+
+**AI agents that don't just _use_ a database — they _operate_ one.** No backend, no human:
+a swarm that coordinates over Apache Kafka, remembers in PostgreSQL + pgvector, and
+**provisions + self-tunes its own Aiven infrastructure — all through the Aiven MCP.**
+
+This Space runs the whole thing in one container: the **agent swarm** (the conductor) plus a
+live read-only **dashboard** (the public page you're looking at). Every agent action is an MCP
+tool call — there are no direct DB/Kafka drivers.
+
+## What it does
+- **Stagger + diversify** — each agent reads the shared Kafka stream and uses a **pgvector**
+  similarity search to pick a measurably different hook at a staggered time. No controller.
+- **Detect + amplify** — the fleet clusters the round's hooks in pgvector, finds the resonating
+  theme, and the owning agent allocates ad budget to double down (Kafka `signals`).
+- **Provision itself** — a new segment agent creates its **own Kafka topic + Postgres state** via the MCP.
+- **Self-optimize** — a watcher agent reads its own query stats, sees the diversify search going
+  full-scan at scale, and provisions a **pgvector HNSW index** itself (~23 ms → ~4 ms).
+- **Decide autonomously** — an LLM **conductor** chooses the swarm's next move each cycle from live state.
+
+## Run it locally
+```bash
+export ANTHROPIC_API_KEY=…   # claude-sonnet for the agents' decisions
+export AIVEN_TOKEN=…         # Aiven personal token, for the MCP
+uv run --with mcp --with anthropic --with fastembed python murmur.py --serve   # the autonomous conductor
+```
+Dashboard: `cd dashboard && uv run --with flask --with "psycopg[binary]" --with python-dotenv python app.py`
+
+## Deploy (this Space)
+One container runs both. Set three **Secrets** in the Space settings:
+`ANTHROPIC_API_KEY`, `AIVEN_TOKEN`, and `DATABASE_URL` (the pg-conductor connection string,
+`postgres://…?sslmode=require`). The dashboard serves on port 7860; the conductor runs alongside it.
+
+## Stack
+Aiven MCP (PostgreSQL + pgvector, Apache Kafka) · claude-sonnet for every decision ·
+fastembed (local 384-dim embeddings) · `murmur.py` (the swarm) + a Flask dashboard.

dashboard/app.py

@@ -44,6 +44,9 @@ def state():
 
 
 if __name__ == "__main__":
-    port = int(os.environ.get("MURMUR_PORT", "5050"))
-    # host stays loopback — this is a local demo viewer, not a public service.
-    app.run(host="127.0.0.1", port=port, debug=False)
+    # Local default: loopback + auto-reload. In a container (Hugging Face Spaces etc.) set
+    # HOST=0.0.0.0, PORT=<public port, e.g. 7860>, FLASK_DEBUG=0 to serve publicly.
+    host = os.environ.get("HOST", "127.0.0.1")
+    port = int(os.environ.get("PORT") or os.environ.get("MURMUR_PORT") or "5050")
+    debug = os.environ.get("FLASK_DEBUG", "1") not in ("0", "false", "no", "")
+    app.run(host=host, port=port, debug=debug)

dashboard/data.py

@@ -317,6 +317,62 @@ def _get_ops(cur, tables, posts, posts_live):
             "budget_total": budget_total, "source": source}
 
 
+def _get_signals(cur, tables, limit=14):
+    """Recent autonomous signals (trend / amplify / optimize) the agents persisted to the
+    `signals` table. Each row's `payload` is jsonb → already a dict via psycopg. (rows, source)."""
+    if "signals" not in tables:
+        return [], "none"
+    cur.execute("SELECT kind, payload, ts FROM signals ORDER BY id DESC LIMIT %s", (limit,))
+    rows = [{"kind": r["kind"], "payload": r["payload"], "ts": _iso(r["ts"])} for r in cur.fetchall()]
+    return rows, ("live" if rows else "empty")
+
+
+def _get_diversity(cur, tables):
+    """Live pgvector readout. For each hook (latest per account+subject) find the nearest
+    peer hook from ANOTHER account within the same ~round window, and return the cosine
+    similarity — the EXACT metric the agents diversify on, recomputed live in Postgres so
+    the feed can show real numbers. Lower sim = more distinct. The 20-minute window scopes
+    it to the round the agent actually diversified against (not all-time near-dupes).
+
+    Read-only; returns {} if hooks/pgvector aren't present. Keyed by (account_id, subject)
+    so it maps cleanly onto `posts` rows in get_state()."""
+    if "hooks" not in tables:
+        return {}
+    try:
+        cur.execute(
+            """
+            WITH h AS (
+              SELECT account_id, subject, embedding, ts,
+                     row_number() OVER (PARTITION BY account_id, subject ORDER BY ts DESC) AS rn
+              FROM hooks
+            )
+            SELECT h.account_id, h.subject,
+                   n.account_id AS near, n.subject AS near_subject, n.sim
+            FROM h
+            LEFT JOIN LATERAL (
+              SELECT o.account_id, o.subject,
+                     round((1 - (h.embedding <=> o.embedding))::numeric, 3)::float8 AS sim
+              FROM hooks o
+              WHERE o.account_id <> h.account_id
+                AND o.ts BETWEEN h.ts - interval '20 minutes' AND h.ts + interval '20 minutes'
+              ORDER BY h.embedding <=> o.embedding
+              LIMIT 1
+            ) n ON true
+            WHERE h.rn = 1
+            """
+        )
+        out = {}
+        for r in cur.fetchall():
+            out[(r["account_id"], r["subject"])] = {
+                "near": r["near"],
+                "near_subject": r["near_subject"],
+                "sim": float(r["sim"]) if r["sim"] is not None else None,
+            }
+        return out
+    except Exception:  # noqa: BLE001 — diversity is a bonus readout; never break the poll
+        return {}
+
+
 # ------------------------------------------------------------------------ public API
 def get_state(limit=60):
     """The whole payload the dashboard polls. Never raises — on any DB error it
@@ -346,7 +402,14 @@ def get_state(limit=60):
             accounts = _get_accounts(cur) if "accounts" in tables else _mock_accounts()
             accounts_src = "live" if "accounts" in tables else "mock (no accounts table)"
             posts, posts_src = _get_posts(cur, tables, limit)
+            # live pgvector diversity: attach each post's real cosine to its nearest peer hook
+            div = _get_diversity(cur, tables) if posts_src == "live" else {}
+            for p in posts:
+                d = div.get((p.get("account_id"), p.get("subject")))
+                if d:
+                    p["sim"], p["near"], p["near_subject"] = d["sim"], d["near"], d["near_subject"]
             ops = _get_ops(cur, tables, posts, posts_live=posts_src == "live")
+            signals, signals_src = _get_signals(cur, tables)
             return {
                 "generated_at": generated_at,
                 "mode": "live",
@@ -354,7 +417,10 @@ def get_state(limit=60):
                 "accounts": accounts,
                 "posts": posts,
                 "ops": ops,
-                "sources": {"accounts": accounts_src, "posts": posts_src, "ops": ops["source"]},
+                "signals": signals,
+                "sources": {"accounts": accounts_src, "posts": posts_src,
+                            "ops": ops["source"], "signals": signals_src,
+                            "diversity": "live (pgvector)" if div else "none"},
             }
     except Exception as e:  # noqa: BLE001 — viewer must stay up; show degraded state
         accounts = _mock_accounts()

dashboard/templates/index.html

@@ -3,145 +3,199 @@
 <head>
 <meta charset="utf-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1" />
-<title>Murmur — live swarm</title>
+<title>MURMUR — live swarm</title>
 <style>
-  :root {
-    --bg:#0b0d12; --panel:#141821; --panel2:#1b212d; --line:#222a38;
-    --ink:#e7ecf3; --dim:#8b97a8; --dimmer:#5b6675;
-    --cyan:#35d0d6; --magenta:#d36bd0; --green:#56d364; --amber:#e3b341; --red:#f06a6a;
-    --flash:#2a3550;
+  :root{
+    --bg:#06070b; --glass:rgba(20,24,34,.62); --glass2:rgba(26,31,44,.55); --line:rgba(120,140,180,.14);
+    --ink:#eaf0f8; --dim:#93a0b4; --dimmer:#5d6a7e;
+    --cyan:#3ad9e0; --magenta:#e070d0; --green:#5be37a; --amber:#ffcb5e; --red:#ff6b6b; --violet:#9b8cff;
   }
-  * { box-sizing:border-box; }
-  body {
-    margin:0; background:var(--bg); color:var(--ink);
-    font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif;
+  *{box-sizing:border-box}
+  html,body{height:100%}
+  body{
+    margin:0; height:100vh; overflow:hidden; display:flex; flex-direction:column;
+    background:radial-gradient(1200px 700px at 78% -10%, rgba(58,217,224,.08) 0, transparent 60%), var(--bg);
+    color:var(--ink); font:13.5px/1.5 ui-sans-serif,system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;
+    -webkit-font-smoothing:antialiased;
   }
-  .mono { font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; }
-  header {
-    display:flex; align-items:center; gap:16px; flex-wrap:wrap;
-    padding:14px 22px; border-bottom:1px solid var(--line); background:#0e1218;
-    position:sticky; top:0; z-index:5;
-  }
-  header h1 { font-size:18px; margin:0; letter-spacing:.3px; }
-  header h1 b { color:var(--cyan); }
-  .status { display:flex; align-items:center; gap:8px; color:var(--dim); font-size:13px; }
-  .dot { width:9px; height:9px; border-radius:50%; background:var(--dimmer); }
-  .dot.live { background:var(--green); box-shadow:0 0 9px var(--green); animation:pulse 2s infinite; }
-  .dot.mock { background:var(--amber); box-shadow:0 0 9px var(--amber); }
-  .dot.err  { background:var(--red); box-shadow:0 0 9px var(--red); }
-  @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.35} }
-  .pill {
-    font-size:11px; padding:2px 8px; border-radius:999px; border:1px solid var(--line);
-    color:var(--dim); background:var(--panel); white-space:nowrap;
-  }
-  .pill.live { color:var(--green); border-color:#1f3a25; }
-  .pill.mock { color:var(--amber); border-color:#3a3320; }
-  .pill.derived { color:var(--cyan); border-color:#193a3b; }
-  .spacer { flex:1; }
+  .mono{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+  #flock{position:fixed; inset:0; z-index:0; pointer-events:none; opacity:.55}
+  .vignette{position:fixed; inset:0; z-index:1; pointer-events:none;
+    background:radial-gradient(120% 90% at 50% 0%, transparent 55%, rgba(0,0,0,.5) 100%)}
 
-  main { padding:20px 22px; display:grid; gap:20px; grid-template-columns:1fr; max-width:1500px; margin:0 auto; }
-  @media (min-width:1050px){ main { grid-template-columns:1.55fr 1fr; } }
-  section h2 {
-    font-size:12px; text-transform:uppercase; letter-spacing:1.4px; color:var(--dim);
-    margin:0 0 12px; display:flex; align-items:center; gap:10px;
-  }
-  .col { display:flex; flex-direction:column; gap:20px; }
+  /* ---- app shell ---- */
+  header{flex:none; z-index:6; display:flex; align-items:center; gap:16px; flex-wrap:wrap;
+    padding:11px 22px; border-bottom:1px solid var(--line);
+    background:linear-gradient(180deg, rgba(8,10,16,.85), rgba(8,10,16,.45)); backdrop-filter:blur(10px)}
+  .brand{display:flex; align-items:baseline; gap:11px}
+  .brand h1{margin:0; font-size:22px; font-weight:800; letter-spacing:2.5px;
+    background:linear-gradient(90deg,var(--cyan),var(--violet) 55%,var(--magenta));
+    -webkit-background-clip:text; background-clip:text; color:transparent; text-shadow:0 0 28px rgba(58,217,224,.25)}
+  .brand .tag{color:var(--dim); font-size:11px; letter-spacing:.3px}
+  @media(max-width:880px){ .brand .tag{display:none} }
+  .status{display:flex; align-items:center; gap:8px; color:var(--dim); font-size:12px}
+  .dot{width:9px; height:9px; border-radius:50%; background:var(--dimmer); flex:none}
+  .dot.live{background:var(--green); box-shadow:0 0 12px var(--green); animation:pulse 1.8s infinite}
+  .dot.mock{background:var(--amber); box-shadow:0 0 12px var(--amber)}
+  .dot.err{background:var(--red); box-shadow:0 0 12px var(--red)}
+  @keyframes pulse{0%,100%{opacity:1}50%{opacity:.3}}
+  .spacer{flex:1}
+  .pill{font-size:11px; padding:3px 9px; border-radius:999px; border:1px solid var(--line);
+    color:var(--dim); background:rgba(255,255,255,.02); white-space:nowrap}
+  .pill b{color:var(--ink); font-weight:700}
+  .pill.live{color:var(--green); border-color:rgba(91,227,122,.35)}
+  .pill.derived{color:var(--cyan); border-color:rgba(58,217,224,.30)}
+  .pill.mock{color:var(--amber); border-color:rgba(255,203,94,.30)}
 
-  /* tile wall */
-  .tiles { display:grid; gap:12px; grid-template-columns:repeat(auto-fill,minmax(220px,1fr)); }
-  .tile {
-    background:var(--panel); border:1px solid var(--line); border-radius:12px; padding:14px;
-    transition:background .6s ease, border-color .6s ease, transform .15s ease;
-    position:relative; overflow:hidden;
-  }
-  .tile.flash { background:var(--flash); border-color:var(--cyan); }
-  .tile .name { font-weight:700; font-size:15px; }
-  .tile .genre { font-size:11px; color:var(--magenta); text-transform:uppercase; letter-spacing:.8px; }
-  .tile .persona { color:var(--dimmer); font-size:11.5px; margin-top:6px; min-height:30px; }
-  .tile .last { margin-top:10px; font-size:12px; color:var(--dim); border-top:1px dashed var(--line); padding-top:8px; }
-  .tile .last .subj { color:var(--ink); }
-  .tile .tdot {
-    position:absolute; top:13px; right:13px; width:8px; height:8px; border-radius:50%;
-    background:var(--dimmer);
-  }
-  .tile.active .tdot { background:var(--green); box-shadow:0 0 8px var(--green); }
-  .badge { display:inline-block; font-size:10px; padding:1px 6px; border-radius:6px; margin-right:5px; }
-  .badge.stagger  { color:var(--cyan); background:#0f2c2e; }
-  .badge.diversify{ color:var(--magenta); background:#2c0f2b; }
+  main{flex:1; min-height:0; z-index:2; position:relative;
+    display:grid; grid-template-columns:1.55fr 1fr; gap:16px; padding:16px 22px; overflow:hidden}
+  @media(max-width:1000px){ main{grid-template-columns:1fr; overflow:auto} }
+  .col{display:flex; flex-direction:column; gap:16px; min-height:0; min-width:0}
+  section{display:flex; flex-direction:column; min-height:0}
+  section h2{flex:none; font-size:10.5px; text-transform:uppercase; letter-spacing:1.5px; color:var(--dim);
+    margin:0 0 9px; display:flex; align-items:center; gap:9px}
+  .count{font-size:10px; color:var(--dim); border:1px solid var(--line); border-radius:999px; padding:2px 8px}
+  .panel{flex:1; min-height:0; background:var(--glass); border:1px solid var(--line); border-radius:14px;
+    backdrop-filter:blur(7px); box-shadow:0 18px 50px -30px rgba(0,0,0,.9); display:flex; flex-direction:column}
+  .scroll{overflow:auto; min-height:0}
 
-  /* feed */
-  .feed { background:var(--panel); border:1px solid var(--line); border-radius:12px; overflow:hidden; }
-  .feed .row {
-    display:grid; grid-template-columns:60px 1fr auto 70px; gap:10px; align-items:baseline;
-    padding:9px 14px; border-bottom:1px solid var(--line); font-size:13px;
-  }
-  .feed .row.new { animation:slidein 1.2s ease; }
-  @keyframes slidein { from{ background:var(--flash); } to{ background:transparent; } }
-  .feed .row:last-child { border-bottom:none; }
-  .feed .acct { color:var(--cyan); font-weight:600; }
-  .feed .acct.b { color:var(--magenta); }
-  .feed .subj { color:var(--ink); }
-  .feed .meta { color:var(--dimmer); font-size:11px; }
-  .feed .perf { color:var(--amber); text-align:right; white-space:nowrap; }
-  .feed .when { color:var(--dim); text-align:right; white-space:nowrap; font-size:11px; }
-  .feedhint { color:var(--dimmer); font-size:11px; margin-top:8px; }
+  /* heights: left col = swarm + feed; right col = signals (grow) + budget + coord (compact) */
+  .s-swarm{flex:1 1 42%}
+  .s-feed{flex:1 1 58%}
+  .s-signals{flex:1 1 auto}
+  .s-fixed{flex:none}
+
+  /* ---- swarm tiles ---- */
+  .tiles{display:grid; gap:11px; grid-template-columns:repeat(auto-fill,minmax(168px,1fr)); align-content:start; padding:13px}
+  .tile{position:relative; padding:12px 13px; border-radius:13px; overflow:hidden;
+    background:var(--glass2); border:1px solid var(--line); transition:transform .25s ease, box-shadow .6s ease, border-color .6s ease}
+  .tile::before{content:""; position:absolute; inset:0; opacity:0; transition:opacity .6s ease;
+    background:radial-gradient(120% 80% at 50% 0%, var(--tc,var(--cyan)), transparent 70%)}
+  .tile.active{border-color:color-mix(in srgb, var(--tc,var(--cyan)) 55%, transparent)}
+  .tile.active::before{opacity:.10}
+  .tile.flash{transform:translateY(-3px); box-shadow:0 0 0 1px var(--tc,var(--cyan)), 0 16px 38px -18px var(--tc,var(--cyan))}
+  .tile.flash::before{opacity:.30}
+  .tile .name{font-weight:800; font-size:14px}
+  .tile .genre{font-size:9.5px; color:var(--tc,var(--magenta)); text-transform:uppercase; letter-spacing:.9px; margin-top:2px}
+  .tile .aid{font-size:9.5px; margin-top:3px; color:var(--tc,var(--cyan)); letter-spacing:.3px; overflow-wrap:anywhere; opacity:.95}
+  .tile .aid .self{display:inline-block; margin-left:6px; font-size:8px; letter-spacing:.5px; text-transform:uppercase;
+    color:var(--green); background:rgba(91,227,122,.12); border:1px solid rgba(91,227,122,.32); border-radius:5px; padding:1px 5px; vertical-align:middle}
+  .tile .persona{color:var(--dim); font-size:10.5px; margin-top:6px; min-height:28px; opacity:.8;
+    display:-webkit-box; -webkit-line-clamp:2; -webkit-box-orient:vertical; overflow:hidden}
+  .tile .last{margin-top:8px; font-size:10.5px; color:var(--dim); border-top:1px solid var(--line); padding-top:6px;
+    white-space:nowrap; overflow:hidden; text-overflow:ellipsis}
+  .tile .last .s{color:var(--ink)}
+  .tile .tdot{position:absolute; top:12px; right:12px; width:6px; height:6px; border-radius:50%; background:var(--dimmer)}
+  .tile.active .tdot{background:var(--tc,var(--cyan)); box-shadow:0 0 9px var(--tc,var(--cyan))}
 
-  /* operator strip */
-  .ops { background:var(--panel); border:1px solid var(--line); border-radius:12px; padding:16px; }
-  .ops .top { font-size:13px; color:var(--dim); margin-bottom:12px; }
-  .ops .top b { color:var(--amber); }
-  .bar { margin-bottom:10px; }
-  .bar .lab { display:flex; justify-content:space-between; font-size:12px; margin-bottom:4px; }
-  .bar .lab .t { color:var(--ink); }
-  .bar .lab .t.spike { color:var(--amber); font-weight:700; }
-  .bar .lab .v { color:var(--dim); }
-  .track { height:9px; background:var(--panel2); border-radius:6px; overflow:hidden; }
-  .fill { height:100%; background:var(--cyan); border-radius:6px; transition:width .8s ease; }
-  .fill.spike { background:linear-gradient(90deg,var(--amber),var(--magenta)); }
+  /* ---- feed ---- */
+  .feed{flex:1}
+  .frow{display:grid; grid-template-columns:92px 1fr 78px; gap:11px; align-items:center;
+    padding:8px 14px; border-bottom:1px solid var(--line)}
+  .frow.new{animation:rowin 1.1s ease}
+  @keyframes rowin{from{background:rgba(58,217,224,.13); transform:translateX(-6px)} to{background:transparent; transform:none}}
+  .frow .acct{font-size:11.5px; font-weight:700; color:var(--tc,var(--cyan)); white-space:nowrap; overflow:hidden; text-overflow:ellipsis}
+  .frow .subj{color:var(--ink)}
+  .frow .vs{color:var(--dim); font-size:10px; margin-left:5px}
+  .frow .vs b{color:var(--magenta); font-weight:600}
+  .frow .right{text-align:right}
+  .frow .perf{font-size:11px; color:var(--amber); font-weight:700}
+  .ptrack{height:4px; border-radius:3px; background:rgba(255,255,255,.06); margin-top:3px; overflow:hidden}
+  .pfill{height:100%; border-radius:3px; background:linear-gradient(90deg,var(--cyan),var(--green)); transition:width .8s ease}
+  .frow .when{font-size:9.5px; color:var(--dimmer)}
+  .frow{align-items:start}
+  .frow .mid{min-width:0}
+  .frow .subjline{display:flex; align-items:baseline; gap:7px; flex-wrap:wrap}
+  .frow .body{color:var(--dim); font-size:10.5px; margin-top:2px; opacity:.8; white-space:nowrap; overflow:hidden; text-overflow:ellipsis}
+  .cos{font-size:10px; color:var(--dim); white-space:nowrap}
+  .cos b{font-weight:600; color:var(--dim)}
+  .cos.distinct, .cos.distinct b{color:var(--green)}
+  .cos.close, .cos.close b{color:var(--amber)}
+  .cos.dup, .cos.dup b{color:var(--red)}
+  .proof{flex:none; padding:8px 14px; color:var(--dimmer); font-size:10.5px; border-top:1px solid var(--line)}
+  .proof code{color:var(--cyan)}
 
-  .legend { color:var(--dimmer); font-size:11px; margin-top:6px; }
-  .err { color:var(--red); font-size:12px; }
+  /* ---- signals ---- */
+  .signals{gap:9px; padding:11px; display:flex; flex-direction:column}
+  .sig{position:relative; padding:10px 12px 10px 14px; border-radius:11px; flex:none;
+    background:var(--glass2); border:1px solid var(--line); overflow:hidden}
+  .sig::before{content:""; position:absolute; left:0; top:0; bottom:0; width:3px; background:var(--sc,var(--cyan))}
+  .sig.new{animation:sigin 1s ease}
+  @keyframes sigin{from{transform:translateY(-8px)} to{transform:none}}
+  .sig .head{display:flex; align-items:center; gap:8px; font-size:9.5px; letter-spacing:1.1px; text-transform:uppercase}
+  .sig .kind{color:var(--sc,var(--cyan)); font-weight:800}
+  .sig .head .t{color:var(--dimmer); margin-left:auto; letter-spacing:0; text-transform:none; font-size:9.5px}
+  .sig .body{margin-top:5px; font-size:12.5px; color:var(--ink)}
+  .sig .sub{margin-top:3px; font-size:10.5px; color:var(--dim)}
+  .sig .big{font-size:18px; font-weight:800; color:var(--sc); letter-spacing:.3px}
+  .sig .arrow{color:var(--green); font-weight:700}
+
+  /* ---- operator + coord ---- */
+  .ops{padding:13px}
+  .ops .top{font-size:11.5px; color:var(--dim); margin-bottom:10px}
+  .ops .top b{color:var(--amber)}
+  .bar{margin-bottom:9px} .bar:last-child{margin-bottom:0}
+  .bar .lab{display:flex; justify-content:space-between; font-size:11.5px; margin-bottom:4px}
+  .bar .lab .t{color:var(--ink)} .bar .lab .t.spike{color:var(--amber); font-weight:800}
+  .bar .lab .v{color:var(--dim)}
+  .track{height:8px; border-radius:6px; background:rgba(255,255,255,.06); overflow:hidden}
+  .fill{height:100%; border-radius:6px; background:var(--cyan); transition:width .9s cubic-bezier(.2,.8,.2,1)}
+  .fill.spike{background:linear-gradient(90deg,var(--amber),var(--magenta)); box-shadow:0 0 14px rgba(255,203,94,.4)}
+  .coord{padding:12px 13px; font-size:11.5px; color:var(--dim)}
+  .coord .row{display:flex; gap:8px; align-items:flex-start; margin-bottom:8px}
+  .coord .row:last-child{margin-bottom:0}
+  .chip{font-size:9px; letter-spacing:.6px; text-transform:uppercase; padding:2px 7px; border-radius:6px; font-weight:700; flex:none}
+  .chip.stagger{color:var(--cyan); background:rgba(58,217,224,.12)}
+  .chip.diversify{color:var(--magenta); background:rgba(224,112,208,.12)}
+  .legend{color:var(--dimmer); font-size:10px; margin-top:7px}
+  .err{color:var(--red); font-size:10.5px}
+  ::-webkit-scrollbar{width:8px; height:8px} ::-webkit-scrollbar-thumb{background:rgba(120,140,180,.18); border-radius:6px}
 </style>
 </head>
 <body>
+<canvas id="flock"></canvas>
+<div class="vignette"></div>
+
 <header>
-  <h1><b>Murmur</b> · live swarm</h1>
-  <div class="status">
-    <span id="dot" class="dot"></span>
-    <span id="statustext">connecting…</span>
-  </div>
+  <div class="brand"><h1>MURMUR</h1><span class="tag">autonomous swarm · live on Aiven · every action through the MCP</span></div>
+  <div class="status"><span id="dot" class="dot"></span><span id="statustext">connecting…</span></div>
   <span class="spacer"></span>
-  <span class="pill" id="p-accounts">accounts —</span>
+  <span class="pill" id="p-acc">agents —</span>
   <span class="pill" id="p-posts">posts —</span>
-  <span class="pill" id="p-ops">budget —</span>
-  <span class="pill mono" id="p-updated">—</span>
+  <span class="pill" id="p-sig">signals —</span>
+  <span class="pill mono" id="p-clock">—</span>
 </header>
 
 <main>
   <div class="col">
-    <section>
-      <h2>The swarm <span class="pill mono" id="tilecount">0 accounts</span></h2>
-      <div class="tiles" id="tiles"></div>
+    <section class="s-swarm">
+      <h2>The swarm <span class="count" id="tilecount">0 agents</span></h2>
+      <div class="panel"><div class="tiles scroll" id="tiles"></div></div>
     </section>
-    <section>
-      <h2>Live feed <span class="pill mono">SELECT * FROM posts ORDER BY created_at DESC</span></h2>
-      <div class="feed" id="feed"></div>
-      <div class="feedhint">Each row is one real DB row. Run the proof query in the agent chat — these tiles must match it.</div>
+    <section class="s-feed">
+      <h2>Live feed <span class="count mono">posts · newest first</span></h2>
+      <div class="panel">
+        <div class="feed scroll" id="feed"></div>
+        <div class="proof">every row = one real Postgres row · <span style="color:var(--magenta)">↯</span> = live pgvector cosine to nearest peer hook (agents reject ≥ 0.80) · <code>SELECT * FROM posts</code></div>
+      </div>
     </section>
   </div>
 
   <div class="col">
-    <section>
-      <h2>Operator · amplify</h2>
-      <div class="ops" id="ops"></div>
-      <div class="legend">Resonating theme detected from post performance → ad budget shifts toward it.</div>
+    <section class="s-signals">
+      <h2>Signals · autonomous decisions <span class="count" id="sigcount">—</span></h2>
+      <div class="panel signals scroll" id="signals"></div>
     </section>
-    <section>
+    <section class="s-fixed">
+      <h2>Amplify · ad budget</h2>
+      <div class="panel ops" id="ops" style="flex:none"></div>
+    </section>
+    <section class="s-fixed">
       <h2>Coordination</h2>
-      <div class="ops">
-        <div class="bar"><span class="badge stagger">stagger</span><span class="meta" id="staggertext">—</span></div>
-        <div class="bar"><span class="badge diversify">diversify</span><span class="meta" id="diversifytext">—</span></div>
-        <div class="legend">No controller, no human — agents read the shared stream, then stagger timing &amp; diversify topic.</div>
+      <div class="panel coord" style="flex:none">
+        <div class="row"><span class="chip stagger">stagger</span><span id="staggertext">—</span></div>
+        <div class="row"><span class="chip diversify">diversify</span><span id="diversifytext">—</span></div>
+        <div class="legend">No controller, no human — agents read the shared Kafka stream, stagger timing, and pgvector-diversify (reject ≥ 0.80 cosine to any peer).</div>
       </div>
     </section>
   </div>
@@ -149,160 +203,184 @@
 
 <script>
 const POLL_MS = 2000;
-let lastByAccount = {};   // account_id -> latest post id (to flash tiles on change)
-let seenPostIds = new Set();   // post ids already shown (to animate only NEW feed rows)
-let firstPaint = true;
+const PALETTE = ["#3ad9e0","#e070d0","#5be37a","#ffcb5e","#9b8cff"];
+let lastByAccount = {}, seenPosts = new Set(), seenSigs = new Set(), first = true;
 
-function fmtClock(iso){
-  if(!iso) return "—";
-  const d = new Date(iso);
-  return d.toLocaleTimeString([], {hour:"2-digit", minute:"2-digit", second:"2-digit"});
-}
-function ago(iso){
-  if(!iso) return "";
-  const s = Math.max(0, Math.floor((Date.now() - new Date(iso).getTime())/1000));
-  if(s < 60) return s + "s ago";
-  if(s < 3600) return Math.floor(s/60) + "m ago";
-  return Math.floor(s/3600) + "h ago";
-}
-function shortName(persona){
-  if(!persona) return "?";
-  return persona.split("—")[0].trim().split(" ")[0];
-}
-function setPill(id, label, src){
-  const el = document.getElementById(id);
-  el.textContent = label + " · " + src;
-  el.className = "pill " + (src.startsWith("live") ? "live" : src.startsWith("derived") ? "derived" : "mock");
-}
+const esc = s => String(s==null?"":s).replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));
+const clock = iso => iso ? new Date(iso).toLocaleTimeString([], {hour:"2-digit",minute:"2-digit",second:"2-digit"}) : "—";
+const ago = iso => { if(!iso) return ""; const s=Math.max(0,(Date.now()-new Date(iso).getTime())/1000|0);
+  return s<60?s+"s":s<3600?(s/60|0)+"m":(s/3600|0)+"h"; };
+const short = p => !p ? "?" : p.split("—")[0].split("–")[0].trim().split(" ")[0];
+const setPill = (id,label,src) => { const e=document.getElementById(id); src=src||"—";
+  e.innerHTML = label+" <b>"+esc(src)+"</b>";
+  e.className = "pill "+(src.startsWith("live")?"live":src.startsWith("derived")?"derived":"mock"); };
 
 function render(s){
-  // ---- status ----
-  const dot = document.getElementById("dot");
-  const st = document.getElementById("statustext");
-  if(s.error){
-    dot.className = "dot err";
-    st.innerHTML = 'DB error — showing mock. <span class="err mono">' + s.error + '</span>';
-  } else if(s.mode === "live"){
-    dot.className = "dot live";
-    st.textContent = "live · polling pg-conductor every " + (POLL_MS/1000) + "s";
-  } else {
-    dot.className = "dot mock";
-    st.textContent = "mock preview · set DATABASE_URL to go live";
-  }
-  document.getElementById("p-updated").textContent = fmtClock(s.generated_at);
-  setPill("p-accounts", "accounts", s.sources.accounts);
-  setPill("p-posts", "posts", s.sources.posts);
-  setPill("p-ops", "budget", s.sources.ops);
+  const sig = s.signals || [];
+  const dot=document.getElementById("dot"), st=document.getElementById("statustext");
+  if(s.error){ dot.className="dot err"; st.innerHTML='DB error — mock. <span class="err mono">'+esc(s.error)+'</span>'; }
+  else if(s.mode==="live"){ dot.className="dot live"; st.textContent="live · polling pg-conductor every "+(POLL_MS/1000)+"s"; }
+  else { dot.className="dot mock"; st.textContent="mock preview · set DATABASE_URL to go live"; }
+  document.getElementById("p-clock").textContent = clock(s.generated_at);
+  setPill("p-acc","agents", s.sources && s.sources.accounts);
+  setPill("p-posts","posts", s.sources && s.sources.posts);
+  setPill("p-sig","signals", (s.sources && s.sources.signals) || "none");
 
-  // ---- index latest post per account ----
-  const latest = {};
-  for(const p of s.posts){
-    if(!(p.account_id in latest)) latest[p.account_id] = p;  // posts are newest-first
-  }
+  const cidx={}; s.accounts.forEach((a,i)=>cidx[a.id]=PALETTE[i%PALETTE.length]);
+  const latest={}; for(const p of s.posts){ if(!(p.account_id in latest)) latest[p.account_id]=p; }
 
-  // ---- tiles ----
-  const tiles = document.getElementById("tiles");
-  tiles.innerHTML = "";
-  const order = Object.keys(latest);
-  s.accounts.forEach((a, i) => {
-    const lp = latest[a.id];
-    const changed = lp && lastByAccount[a.id] !== undefined && lastByAccount[a.id] !== lp.id;
-    const div = document.createElement("div");
-    div.className = "tile" + (lp ? " active" : "") + ((changed && !firstPaint) ? " flash" : "");
-    let lastHtml = '<div class="last">quiet — no posts yet</div>';
-    if(lp){
-      lastHtml = '<div class="last">last: <span class="subj">' +
-        (lp.subject ? esc(lp.subject) : "—") + '</span> · <span class="mono">' + ago(lp.created_at) + '</span></div>';
+  // tiles
+  const tiles=document.getElementById("tiles"); tiles.innerHTML="";
+  s.accounts.forEach(a=>{
+    const lp=latest[a.id], col=cidx[a.id];
+    const changed=lp && lastByAccount[a.id]!==undefined && lastByAccount[a.id]!==lp.id && !first;
+    const d=document.createElement("div");
+    d.className="tile"+(lp?" active":"")+(changed?" flash":""); d.style.setProperty("--tc",col);
+    // self-provisioned = onboarded via the MCP (segment id, not the seeded acct_NN / mock acct_a/b)
+    const self = /^acct_/.test(a.id) && !/^acct_\d+$/.test(a.id) && !/^acct_[ab]$/.test(a.id);
+    d.innerHTML='<span class="tdot"></span>'+
+      '<div class="name">'+esc(short(a.persona)||a.id)+'</div>'+
+      '<div class="aid mono">'+esc(a.id)+(self?'<span class="self">self-provisioned</span>':'')+'</div>'+
+      '<div class="persona" title="'+esc(a.persona||"")+'">'+esc(a.persona||"")+'</div>'+
+      (lp?'<div class="last" title="'+esc(lp.subject||"")+'">latest: <span class="s">'+esc(lp.subject||"—")+'</span> · '+ago(lp.created_at)+'</div>'
+         :'<div class="last">quiet — no posts yet</div>');
+    tiles.appendChild(d);
+    if(changed) setTimeout(()=>d.classList.remove("flash"),1100);
+  });
+  document.getElementById("tilecount").textContent=s.accounts.length+" agents";
+  const nl={}; for(const a of s.accounts) if(latest[a.id]) nl[a.id]=latest[a.id].id; lastByAccount=nl;
+
+  // feed
+  const feed=document.getElementById("feed"); feed.innerHTML="";
+  const now=new Set();
+  if(!s.posts.length) feed.innerHTML='<div class="frow"><span></span><span class="vs">waiting for the swarm…</span><span></span></div>';
+  s.posts.forEach(p=>{
+    const id=String(p.id); now.add(id); const isNew=!first&&!seenPosts.has(id);
+    const perf=p.performance!=null?Math.round(p.performance):null;
+    const r=document.createElement("div"); r.className="frow"+(isNew?" new":""); r.style.setProperty("--tc",cidx[p.account_id]||"#3ad9e0");
+    // live pgvector cosine to nearest peer (lower = more distinct); fall back to stored diversified_from
+    let cos="";
+    if(p.sim!=null){
+      const cls = p.sim>=0.80 ? "dup" : p.sim>=0.70 ? "close" : "distinct";
+      const tip = "live pgvector cosine to nearest peer"+(p.near_subject?": “"+esc(p.near_subject)+"”":"");
+      cos='<span class="cos '+cls+'" title="'+tip+'">↯ '+p.sim.toFixed(2)+(p.sim>=0.999?" collision":"")+' vs <b>'+esc(p.near||"?")+'</b></span>';
+    } else if(p.diversified_from){
+      cos='<span class="cos">↯ vs <b>'+esc(p.diversified_from)+'</b></span>';
     }
-    div.innerHTML =
-      '<span class="tdot"></span>' +
-      '<div class="name">' + esc(shortName(a.persona) || a.id) + '</div>' +
-      '<div class="genre">' + esc(a.genre || "") + '</div>' +
-      '<div class="persona">' + esc(a.persona || a.id) + '</div>' +
-      lastHtml;
-    tiles.appendChild(div);
-    if(changed && !firstPaint){ setTimeout(() => div.classList.remove("flash"), 900); }
+    const body = p.body?'<div class="body" title="'+esc(p.body)+'">'+esc(p.body)+'</div>':"";
+    r.innerHTML='<span class="acct mono" title="'+esc(p.account_id||"")+'">'+esc(p.account_id||"?")+'</span>'+
+      '<span class="mid"><span class="subjline"><span class="subj">'+(p.subject?esc(p.subject):'<span class="vs">(post)</span>')+'</span>'+cos+'</span>'+
+        body+
+        (perf!=null?'<div class="ptrack"><div class="pfill" style="width:'+Math.min(100,perf)+'%"></div></div>':'')+'</span>'+
+      '<span class="right"><div class="perf">'+(perf!=null?perf:"—")+'</div><div class="when mono">'+clock(p.created_at)+'</div></span>';
+    feed.appendChild(r);
   });
-  document.getElementById("tilecount").textContent = s.accounts.length + " accounts";
-  // remember latest ids for next diff
-  const nl = {};
-  for(const a of s.accounts){ if(latest[a.id]) nl[a.id] = latest[a.id].id; }
-  lastByAccount = nl;
+  seenPosts=now;
 
-  // ---- feed ----
-  const feed = document.getElementById("feed");
-  feed.innerHTML = "";
-  const accIndex = {}; s.accounts.forEach((a,i)=>accIndex[a.id]=i);
-  const nowSeen = new Set();
-  s.posts.forEach(p => {
-    const idStr = String(p.id);
-    nowSeen.add(idStr);
-    const isNew = !firstPaint && !seenPostIds.has(idStr);
-    const row = document.createElement("div");
-    row.className = "row" + (isNew ? " new" : "");
-    const isB = (accIndex[p.account_id] || 0) % 2 === 1;
-    const perf = (p.performance!=null) ? Math.round(p.performance).toLocaleString() : "—";
-    row.innerHTML =
-      '<span class="acct' + (isB?" b":"") + ' mono">' + esc(p.account_id||"?") + '</span>' +
-      '<span><span class="subj">' + (p.subject?esc(p.subject):'<span class="meta">(post)</span>') + '</span>' +
-        (p.diversified_from ? ' <span class="meta">↯ vs ' + esc(p.diversified_from) + '</span>' : '') + '</span>' +
-      '<span class="perf">' + perf + '</span>' +
-      '<span class="when mono" title="' + esc(p.created_at||"") + '">' + fmtClock(p.created_at) + '</span>';
-    feed.appendChild(row);
+  // signals
+  const SC={trend:"#3ad9e0", amplify:"#ffcb5e", optimize:"#e070d0"};
+  const rail=document.getElementById("signals"); rail.innerHTML="";
+  document.getElementById("sigcount").textContent = sig.length ? sig.length+" recent" : "none yet";
+  if(!sig.length) rail.innerHTML='<div class="sig" style="--sc:#5d6a7e"><div class="body" style="color:var(--dim)">No signals yet — run a round (trend+amplify) or <span class="mono">--tier2</span> (optimize).</div></div>';
+  const nowS=new Set();
+  sig.forEach(x=>{
+    const p=x.payload||{}, k=x.kind||p.type||"signal";
+    const key=k+"|"+(x.ts||"")+"|"+(p.theme||p.query||""); nowS.add(key);
+    const isNew=!first&&!seenSigs.has(key);
+    let head, body, sub="";
+    if(k==="trend"){ head="Trend detected";
+      body='“'+esc(p.theme)+'” is resonating';
+      sub='avg performance '+esc(p.avg_performance)+'/100 · '+((p.members||[]).length)+' agents · leader '+esc(p.leader); }
+    else if(k==="amplify"){ head="Amplify · ad budget";
+      body='<span class="big">$'+esc(p.budget_usd)+'</span> → “'+esc(p.theme)+'”';
+      sub=esc(p.account_id)+' · '+esc(p.reason||""); }
+    else if(k==="optimize"){ head="Self-optimize · pgvector";
+      body=esc(p.scan_before)+' '+esc(p.before_ms)+'ms <span class="arrow">→</span> '+esc(p.scan_after)+' '+esc(p.after_ms)+'ms';
+      sub='<b style="color:var(--green)">'+esc(p.speedup)+'× faster</b> · recall '+esc(p.recall_pct)+'% · '+esc(p.index)+' index @ '+esc(p.rows)+' rows'; }
+    else { head=esc(k); body=esc(JSON.stringify(p)).slice(0,120); }
+    const d=document.createElement("div"); d.className="sig"+(isNew?" new":""); d.style.setProperty("--sc",SC[k]||"#9b8cff");
+    d.innerHTML='<div class="head"><span class="kind">'+esc(head)+'</span><span class="t mono">'+ago(x.ts)+'</span></div>'+
+      '<div class="body">'+body+'</div>'+(sub?'<div class="sub">'+sub+'</div>':'');
+    rail.appendChild(d);
   });
-  seenPostIds = nowSeen;
-  if(s.posts.length === 0){
-    feed.innerHTML = '<div class="row"><span class="meta">no posts yet — waiting for the swarm…</span></div>';
-  }
+  seenSigs=nowS;
 
-  // ---- operator strip ----
-  const ops = document.getElementById("ops");
-  const o = s.ops || {themes:[]};
-  let html = '<div class="top">resonating theme: <b>' + (o.top?esc(o.top):"—") +
-             '</b> · budget pool ' + (o.budget_total||0).toLocaleString() + '</div>';
-  const max = Math.max(1, ...o.themes.map(t=>t.budget||0));
-  for(const t of o.themes){
-    const w = Math.round(100*(t.budget||0)/max);
-    html += '<div class="bar"><div class="lab"><span class="t' + (t.spike?" spike":"") + '">' +
-      esc(t.theme) + (t.spike?" ◀ amplifying":"") + '</span><span class="v">' +
-      Math.round(t.budget||0).toLocaleString() + '</span></div>' +
-      '<div class="track"><div class="fill' + (t.spike?" spike":"") + '" style="width:' + w + '%"></div></div></div>';
-  }
-  ops.innerHTML = html;
+  // operator: themes COMPETE by performance momentum; the theme the agent actually amplified
+  // spikes and shows its real ad budget. Always multi-bar so the budget *shift* is visible.
+  const ops=document.getElementById("ops");
+  const o=s.ops||{themes:[]};
+  let bars=(o.themes||[]).slice(0,5).map(t=>({theme:t.theme, val:(t.momentum!=null?t.momentum:t.budget)||0}));
+  const amp=sig.filter(x=>(x.kind||(x.payload&&x.payload.type))==="amplify").map(x=>x.payload||{});
+  const a0=amp.find(p=>p.theme);
+  let winner=o.top||(bars[0]&&bars[0].theme)||"—", budget=null;
+  if(a0){ winner=a0.theme; budget=+a0.budget_usd||0;
+    if(!bars.some(b=>b.theme===winner)) bars.unshift({theme:winner, val:Math.max(1,...bars.map(b=>b.val||0))}); }
+  bars=bars.slice(0,5); bars.forEach(b=>b.spike=(b.theme===winner));
+  if(bars.length && !bars.some(b=>b.spike)){ bars[0].spike=true; winner=bars[0].theme; }
+  const max=Math.max(1,...bars.map(b=>b.val));
+  const src = budget!=null ? "live · agent put $"+budget.toLocaleString()+" behind it" : (o.source||"derived from performance");
+  let html='<div class="top">resonating: <b>'+esc(winner)+'</b> · <span class="mono" style="font-size:9.5px">'+esc(src)+'</span></div>';
+  for(const b of bars){ const w=Math.round(100*(b.val||0)/max);
+    const tag=b.spike?(budget!=null?' ◀ $'+budget.toLocaleString():' ◀ amplifying'):'';
+    const rightv=b.spike&&budget!=null?'$'+budget.toLocaleString():Math.round(b.val).toLocaleString();
+    html+='<div class="bar"><div class="lab"><span class="t'+(b.spike?" spike":"")+'">'+esc(b.theme)+tag+'</span><span class="v">'+rightv+'</span></div>'+
+      '<div class="track"><div class="fill'+(b.spike?" spike":"")+'" style="width:'+w+'%"></div></div></div>'; }
+  if(!bars.length) html+='<div class="legend">no posts yet — run a round</div>';
+  ops.innerHTML=html;
 
-  // ---- coordination summary ----
-  const posts = s.posts.slice().sort((a,b)=> new Date(a.created_at)-new Date(b.created_at));
-  let staggerTxt = "—", diversifyTxt = "—";
-  if(posts.length >= 2){
-    const a1 = posts[posts.length-2], a2 = posts[posts.length-1];
-    const gap = Math.abs((new Date(a2.created_at)-new Date(a1.created_at))/1000);
-    staggerTxt = "last two posts " + Math.round(gap) + "s apart (" + esc(a1.account_id) + " → " + esc(a2.account_id) + ")";
-    diversifyTxt = a1.subject && a2.subject
-      ? (a1.subject.toLowerCase()===a2.subject.toLowerCase()
-          ? "repeat detected: “" + esc(a2.subject) + "”"
-          : "“" + esc(a1.subject) + "” → “" + esc(a2.subject) + "” (different hooks)")
-      : "subjects not in schema yet";
+  // coordination
+  const ps=s.posts.slice().sort((a,b)=>new Date(a.created_at)-new Date(b.created_at));
+  let sg="—", dv="—";
+  if(ps.length>=2){ const a=ps[ps.length-2], b=ps[ps.length-1];
+    const gap=Math.abs((new Date(b.created_at)-new Date(a.created_at))/1000)|0;
+    sg=esc(a.account_id)+" → "+esc(b.account_id)+", "+gap+"s apart (no collision)";
+    dv=a.subject&&b.subject?'“'+esc(a.subject)+'” → “'+esc(b.subject)+'” — different hooks':"distinct hooks per agent"; }
+  // real pgvector readout: cosine range + the single most-distinct hook this round
+  const sims=s.posts.filter(p=>p.sim!=null);
+  if(sims.length){
+    const lo=Math.min(...sims.map(p=>p.sim)), hi=Math.max(...sims.map(p=>p.sim));
+    const m=sims.slice().sort((a,b)=>a.sim-b.sim)[0];
+    dv='nearest-peer cosine <b style="color:var(--ink)">'+lo.toFixed(2)+'–'+hi.toFixed(2)+'</b> · most distinct: “'+esc(m.subject)+'” <b style="color:var(--green)">'+m.sim.toFixed(2)+'</b>';
   }
-  document.getElementById("staggertext").innerHTML = staggerTxt;
-  document.getElementById("diversifytext").innerHTML = diversifyTxt;
-
-  firstPaint = false;
+  document.getElementById("staggertext").innerHTML=sg;
+  document.getElementById("diversifytext").innerHTML=dv;
+  first=false;
 }
 
-function esc(s){ return String(s).replace(/[&<>"]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c])); }
-
 async function tick(){
-  try {
-    const r = await fetch("/api/state", {cache:"no-store"});
-    render(await r.json());
-  } catch(e){
-    const dot = document.getElementById("dot");
-    dot.className = "dot err";
-    document.getElementById("statustext").textContent = "dashboard offline — " + e;
-  }
+  try{ const r=await fetch("/api/state",{cache:"no-store"}); render(await r.json()); }
+  catch(e){ const d=document.getElementById("dot"); d.className="dot err";
+    document.getElementById("statustext").textContent="dashboard offline — "+e; }
 }
-tick();
-setInterval(tick, POLL_MS);
+tick(); setInterval(tick, POLL_MS);
+
+/* ---- murmuration background (lightweight boids) ---- */
+(function(){
+  const cv=document.getElementById("flock"), ctx=cv.getContext("2d");
+  let W,H,DPR; const COL=["58,217,224","224,112,208","155,140,255"];
+  const N=Math.min(170, Math.max(70, Math.round((innerWidth*innerHeight)/12000))); let B=[];
+  function size(){ DPR=Math.min(2,devicePixelRatio||1); W=cv.width=innerWidth*DPR; H=cv.height=innerHeight*DPR;
+    cv.style.width=innerWidth+"px"; cv.style.height=innerHeight+"px"; }
+  size(); addEventListener("resize", size);
+  for(let i=0;i<N;i++) B.push({x:Math.random()*W,y:Math.random()*H,
+    vx:(Math.random()-.5)*0.5*DPR, vy:(Math.random()-.5)*0.5*DPR, c:COL[i%COL.length]});
+  const R2=(70*DPR)**2, MAX=1.1*DPR, SEP2=(26*DPR)**2, LINK2=(34*DPR)**2;
+  function step(){
+    ctx.clearRect(0,0,W,H);
+    for(let i=0;i<B.length;i++){ const a=B[i]; let ax=0,ay=0,cx=0,cy=0,sx=0,sy=0,n=0;
+      for(let j=0;j<B.length;j++){ if(i===j) continue; const b=B[j]; const dx=b.x-a.x, dy=b.y-a.y; const d2=dx*dx+dy*dy;
+        if(d2<R2){ n++; ax+=b.vx; ay+=b.vy; cx+=b.x; cy+=b.y; if(d2<SEP2){ sx-=dx; sy-=dy; }
+          if(d2<LINK2){ ctx.strokeStyle="rgba("+a.c+",0.05)"; ctx.lineWidth=DPR*0.5; ctx.beginPath(); ctx.moveTo(a.x,a.y); ctx.lineTo(b.x,b.y); ctx.stroke(); } } }
+      if(n){ a.vx+=((ax/n)-a.vx)*0.04+(cx/n-a.x)*0.0006+sx*0.004; a.vy+=((ay/n)-a.vy)*0.04+(cy/n-a.y)*0.0006+sy*0.004; }
+      const sp=Math.hypot(a.vx,a.vy)||1; if(sp>MAX){ a.vx=a.vx/sp*MAX; a.vy=a.vy/sp*MAX; }
+      a.x+=a.vx; a.y+=a.vy;
+      if(a.x<0)a.x+=W; if(a.x>W)a.x-=W; if(a.y<0)a.y+=H; if(a.y>H)a.y-=H;
+      ctx.fillStyle="rgba("+a.c+",0.9)"; ctx.beginPath(); ctx.arc(a.x,a.y,1.4*DPR,0,6.283); ctx.fill();
+    }
+    requestAnimationFrame(step);
+  }
+  step();
+})();
 </script>
 </body>
 </html>

murmur.py

@@ -36,10 +36,11 @@ Transport: connects to the hosted Aiven MCP (https://mcp.aiven.live/mcp) using A
 as a bearer; if that endpoint lacks the write tools (read-only), it falls back to spawning
 the bundled local server (./mcp-aiven, built with `npm install && npm run build`) over stdio.
 
-Deploy (step 4): `python murmur.py --serve` runs it as a long-running worker — a status
-endpoint on $PORT (default 8080) plus a coordination round every $MURMUR_INTERVAL seconds
-(default 300). The Dockerfile builds exactly this; deploy via Aiven Apps with ANTHROPIC_API_KEY
-and AIVEN_TOKEN injected as secrets — still all via the MCP, no direct DB/Kafka drivers.
+Autonomous mode: `python murmur.py --serve` runs the CONDUCTOR loop — a status endpoint on
+$PORT (default 8080) plus, every $MURMUR_INTERVAL seconds (default 180), an LLM decision on the
+swarm's next move (round / onboard / optimize / idle) from its own live state. No human, no
+fixed schedule of actions. The Dockerfile builds exactly this; run it under launchd/cron or
+(when access is granted) Aiven Apps with ANTHROPIC_API_KEY + AIVEN_TOKEN as secrets — all via the MCP.
 """
 
 import asyncio
@@ -255,6 +256,13 @@ async def store_post(session, account_id, subject, body, performance, diversifie
         f"VALUES ('{sql_str(account_id)}', '{sql_str(subject)}', '{sql_str(body)}', "
         f"{perf}, {div}, '{sql_str(scheduled_for)}')")
 
+async def store_signal(session, kind, payload):
+    """Durable, dashboard-readable copy of a Kafka `signals` event (trend/amplify/optimize),
+    so the wall can show the real autonomous decisions — not a re-derived stand-in."""
+    await pg_write(session,
+        f"INSERT INTO signals (kind, payload) VALUES "
+        f"('{sql_str(kind)}', '{sql_str(json.dumps(payload))}'::jsonb)")
+
 # --- Tier 2 observe/optimize MCP wrappers ---
 async def query_stats(session, order_by="total_time:desc", limit=5, search=None):
     args = {"project": PROJECT, "service_name": PG_SVC, "order_by": order_by, "limit": limit}
@@ -305,6 +313,26 @@ def persona_system(me):
             f"fleet. Your genre is '{me['genre']}'. You think briefly, in character, then act. "
             f"Always answer with a single JSON object only.")
 
+def conductor_decide(state):
+    """The autonomous conductor: decide the swarm's NEXT MOVE from its live state (LLM, not a timer)."""
+    msg = AC.messages.create(
+        model=MODEL, max_tokens=220,
+        system="You are the autonomous conductor of Murmur, a self-running book-marketing agent swarm "
+               "on Aiven. You decide the swarm's next move from its live state — there is no human and "
+               "no schedule. Answer with a single JSON object only.",
+        messages=[{"role": "user", "content":
+            f"Live state: {state['agents']} agents · {state['recent_posts']} posts in the last 30min · "
+            f"{state['mins_since_post']} min since the last post · {state['hooks']} hooks in pgvector memory · "
+            f"last self-optimize {state['mins_since_optimize']} min ago · resonating theme: \"{state['top_theme']}\".\n"
+            "Decide the next move. Options: 'round' (agents post, diversify vs peers, the fleet detects a "
+            "trend & amplifies it); 'onboard' (recruit a NEW audience-segment agent — give a 2-4 word "
+            "segment); 'optimize' (self-tune the pgvector memory index — only worthwhile once memory has "
+            "grown a lot); 'idle' (wait, if it just acted). Keep the network alive and varied; don't "
+            "onboard every cycle. Reply ONLY JSON: "
+            '{"action":"round|onboard|optimize|idle","segment":"<only if onboard>","reason":"<one sentence>"}'}])
+    raw = "".join(b.text for b in msg.content if getattr(b, "type", None) == "text")
+    return extract_json(raw)
+
 # ----------------------------------------------------------------------------- setup (idempotent)
 async def ensure_schema(session):
     """Create the tables, pgvector extension, and shared topics — idempotent, all via MCP."""
@@ -322,6 +350,9 @@ async def ensure_schema(session):
         "CREATE TABLE IF NOT EXISTS posts (id bigserial PRIMARY KEY, "
         "account_id text REFERENCES accounts(id), subject text, body text, performance numeric, "
         "diversified_from text, scheduled_for text, created_at timestamptz NOT NULL DEFAULT now())")
+    await pg_write(session,
+        "CREATE TABLE IF NOT EXISTS signals (id bigserial PRIMARY KEY, kind text NOT NULL, "
+        "payload jsonb NOT NULL, ts timestamptz NOT NULL DEFAULT now())")
     for topic in (POSTS, SIGNALS):
         try:  # topics are usually pre-created; tolerate "already exists"
             await call(session, "aiven_kafka_topic_create", {
@@ -448,10 +479,11 @@ async def detect_and_amplify(session, since_db):
     for r in members:
         print(f"      {DIM}{r['account_id']:8} sim={r['sim_to_leader']} perf={r['performance']}  {r['subject']}{RESET}")
 
-    await produce(session, SIGNALS, [{"key": {"theme": theme}, "value": {
-        "type": "trend", "theme": theme, "leader": leader_acct,
-        "members": [r["account_id"] for r in members], "avg_performance": avg_perf, "ts": now_iso()}}])
-    step(f"emitted trend signal to kafka topic '{SIGNALS}'")
+    trend_sig = {"type": "trend", "theme": theme, "leader": leader_acct,
+                 "members": [r["account_id"] for r in members], "avg_performance": avg_perf, "ts": now_iso()}
+    await produce(session, SIGNALS, [{"key": {"theme": theme}, "value": trend_sig}])
+    await store_signal(session, "trend", trend_sig)
+    step(f"emitted trend signal to kafka topic '{SIGNALS}' (+ durable copy)")
 
     # amplify: the theme owner allocates ad budget and doubles down (legit marketing ops)
     me = await load_account(session, leader_acct)
@@ -473,10 +505,11 @@ async def detect_and_amplify(session, since_db):
     await pg_write(session,
         f"INSERT INTO events (account_id, type, topic) VALUES ('{sql_str(leader_acct)}', 'amplify', '{SIGNALS}')")
     await store_post(session, leader_acct, theme, text, avg_perf, None, "now (amplified)")
-    await produce(session, SIGNALS, [{"key": {"account_id": leader_acct}, "value": {
-        "type": "amplify", "account_id": leader_acct, "theme": theme, "budget_usd": budget,
-        "text": text, "reason": reason, "ts": now_iso()}}])
-    step(f"wrote amplify event + durable posts row + produced to '{SIGNALS}'")
+    amp_sig = {"type": "amplify", "account_id": leader_acct, "theme": theme, "budget_usd": budget,
+               "text": text, "reason": reason, "ts": now_iso()}
+    await produce(session, SIGNALS, [{"key": {"account_id": leader_acct}, "value": amp_sig}])
+    await store_signal(session, "amplify", amp_sig)
+    step(f"wrote amplify event + durable posts/signal rows + produced to '{SIGNALS}'")
     return {"theme": theme, "leader": leader_acct, "budget": budget, "avg_performance": avg_perf}
 
 # ----------------------------------------------------------------------------- ledger
@@ -675,11 +708,12 @@ async def tier2_optimize(session):
           f"(was {before_ms:.1f} ms · {BOLD}{speedup}× faster{RESET}) · recall@10 {GREEN}{recall}%{RESET}")
 
     # 6) EMIT — announce the optimization on the signals bus
-    await produce(session, SIGNALS, [{"key": {"type": "optimize"}, "value": {
-        "type": "optimize", "query": "diversify-nn", "rows": seeded, "scan_before": before_scan,
-        "scan_after": after_scan, "before_ms": round(before_ms, 1), "after_ms": round(after_ms, 1),
-        "speedup": speedup, "recall_pct": recall, "index": itype, "ts": now_iso()}}])
-    step(f"emitted optimization signal to '{SIGNALS}'")
+    opt_sig = {"type": "optimize", "query": "diversify-nn", "rows": seeded, "scan_before": before_scan,
+               "scan_after": after_scan, "before_ms": round(before_ms, 1), "after_ms": round(after_ms, 1),
+               "speedup": speedup, "recall_pct": recall, "index": itype, "ts": now_iso()}
+    await produce(session, SIGNALS, [{"key": {"type": "optimize"}, "value": opt_sig}])
+    await store_signal(session, "optimize", opt_sig)
+    step(f"emitted optimization signal to '{SIGNALS}' (+ durable copy)")
 
     # 7) CLEANUP — drain the bench (empty table+index persist, never read by the swarm)
     await pg_write(session, f"DELETE FROM {bench}")
@@ -729,8 +763,8 @@ async def connect_and_run(token, runner=None):
     raise SystemExit(f"Could not reach the Aiven MCP on any transport. Last error: {last_err}")
 
 # ----------------------------------------------------------------------------- deploy mode (worker)
-STATUS = {"service": "murmur-fleet", "fleet_size": FLEET_SIZE, "rounds": 0,
-          "last_round": None, "last_error": None}
+STATUS = {"service": "murmur-fleet", "fleet_size": FLEET_SIZE, "cycles": 0,
+          "last_decision": None, "last_round": None, "last_error": None}
 
 def _truthy(v):
     return str(v).strip().lower() in ("1", "true", "yes", "on")
@@ -750,19 +784,53 @@ def serve_status(port):
             return
     HTTPServer(("0.0.0.0", port), Handler).serve_forever()
 
+async def conductor_cycle(session):
+    """One autonomous cycle: observe the swarm's own state via the MCP, let the LLM conductor decide
+    the next move, then dispatch it. Initiative is LLM-made, not clock-driven."""
+    await ensure_schema(session)
+    row = (await pg_read(session,
+        "SELECT (SELECT count(*) FROM posts WHERE created_at > now()-interval '30 minutes') AS recent_posts, "
+        "(SELECT count(*) FROM accounts) AS agents, (SELECT count(*) FROM hooks) AS hooks, "
+        "COALESCE(round(extract(epoch FROM (now()-(SELECT max(created_at) FROM posts)))/60)::int, 999) AS mins_since_post, "
+        "COALESCE(round(extract(epoch FROM (now()-(SELECT max(ts) FROM signals WHERE kind='optimize')))/60)::int, 999) AS mins_since_optimize, "
+        "COALESCE((SELECT payload->>'theme' FROM signals WHERE kind='trend' ORDER BY id DESC LIMIT 1), '—') AS top_theme"))[0]
+    state = {k: row.get(k) for k in ("recent_posts", "agents", "hooks", "mins_since_post", "mins_since_optimize", "top_theme")}
+
+    banner(BLUE, "◆ conductor", "observing the swarm + deciding the next move (no human, no schedule)")
+    step(f"{DIM}state: {state['agents']} agents · {state['recent_posts']} posts/30m · "
+         f"{state['mins_since_post']}m since last post · {state['hooks']} hooks · theme \"{state['top_theme']}\"{RESET}")
+    print(f"   {DIM}thinking with {MODEL}…{RESET}")
+    d = await asyncio.to_thread(conductor_decide, state)
+    action = (d.get("action") or "round").strip().lower()
+    if action not in ("round", "onboard", "optimize", "idle"):
+        action = "round"
+    reason = d.get("reason", "").strip()
+    print(f"   decision: {BOLD}{action.upper()}{RESET} — {DIM}{reason}{RESET}")
+    STATUS["last_decision"] = {"action": action, "reason": reason, "ts": now_iso()}
+
+    if action == "round":
+        return await do_demo(session)
+    if action == "onboard":
+        return await onboard(session, d.get("segment") or "new-segment")
+    if action == "optimize":
+        return await tier2_optimize(session)
+    step("idle — letting the stream settle")
+    return {"action": "idle", "reason": reason}
+
 async def worker(token):
-    """Run coordination rounds forever, every MURMUR_INTERVAL seconds, updating STATUS.
-    A failed round must never kill the worker — it logs and tries again next interval."""
-    interval = int(os.environ.get("MURMUR_INTERVAL", "300"))
+    """The autonomous conductor loop: every MURMUR_INTERVAL seconds the swarm DECIDES (via the LLM
+    conductor) and acts. A failed cycle must never kill the loop — log and try again next interval."""
+    interval = int(os.environ.get("MURMUR_INTERVAL", "180"))
+    print(f"{GREEN}[conductor] autonomous loop started — a fresh decision every ~{interval}s{RESET}")
     while True:
         try:
-            STATUS["last_round"] = await connect_and_run(token)
-            STATUS["rounds"] += 1
+            STATUS["last_round"] = await connect_and_run(token, conductor_cycle)
+            STATUS["cycles"] = STATUS.get("cycles", 0) + 1
             STATUS["last_error"] = None
-        except Exception as e:                       # noqa: BLE001 — keep the worker alive
+        except Exception as e:                       # noqa: BLE001 — keep the loop alive
             STATUS["last_error"] = str(e)[:200]
-            print(f"{YELLOW}[worker] round failed: {e}{RESET}")
-        print(f"{DIM}[worker] sleeping {interval}s until next round{RESET}")
+            print(f"{YELLOW}[conductor] cycle failed: {e}{RESET}")
+        print(f"{DIM}[conductor] next decision in {interval}s{RESET}")
         await asyncio.sleep(interval)
 
 def load_dotenv():
@@ -811,8 +879,8 @@ def main():
     elif "--serve" in sys.argv or _truthy(os.environ.get("MURMUR_SERVE", "")):
         port = int(os.environ.get("PORT", "8080"))
         threading.Thread(target=serve_status, args=(port,), daemon=True).start()
-        print(f"{GREEN}[worker] status endpoint on 0.0.0.0:{port} · round every "
-              f"{os.environ.get('MURMUR_INTERVAL', '300')}s{RESET}")
+        print(f"{GREEN}[conductor] status endpoint on 0.0.0.0:{port} · autonomous — the swarm decides "
+              f"its own move every {os.environ.get('MURMUR_INTERVAL', '180')}s{RESET}")
         asyncio.run(worker(token))
     else:
         asyncio.run(connect_and_run(token))