@umbra-privacy/ceremony 0.2.6 → 0.2.9

package/dist/index.js

@@ -4,23 +4,38 @@
 import { render } from "ink";
 
 // src/components/App.tsx
-import { useEffect as useEffect5, useState as useState5 } from "react";
-import { Box as Box7, Text as Text7, useApp, useInput as useInput2 } from "ink";
+import { useEffect as useEffect6, useState as useState6 } from "react";
+import { Box as Box8, Text as Text8, useApp, useInput as useInput3 } from "ink";
 
 // src/cleanup.ts
 var pendingLeaveQueue = null;
+var pendingClearSession = null;
 function setQueueCleanup(fn) {
   pendingLeaveQueue = fn;
 }
 function clearQueueCleanup() {
   pendingLeaveQueue = null;
 }
+function setSessionCleanup(fn) {
+  pendingClearSession = fn;
+}
+function clearSessionCleanup() {
+  pendingClearSession = null;
+}
 async function runQueueCleanup() {
   if (!pendingLeaveQueue) return;
   pendingLeaveQueue();
   pendingLeaveQueue = null;
   await new Promise((resolve) => setTimeout(resolve, 800));
 }
+async function runSessionCleanup() {
+  if (!pendingClearSession) return;
+  try {
+    await pendingClearSession();
+  } catch {
+  }
+  pendingClearSession = null;
+}
 
 // src/session.ts
 import { readFile as readFile2, unlink as unlink2, writeFile } from "fs/promises";
@@ -227,7 +242,16 @@ var STORE_FILE = process.env["CEREMONY_CONTRIBUTIONS_FILE"] ?? join2(homedir2(),
 async function load() {
   try {
     const raw = await readFile3(STORE_FILE, "utf8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    const out = {};
+    for (const [trackId, value] of Object.entries(parsed)) {
+      if (Array.isArray(value)) {
+        out[trackId] = value;
+      } else if (value && typeof value === "object") {
+        out[trackId] = [value];
+      }
+    }
+    return out;
   } catch {
     return {};
   }
@@ -240,9 +264,21 @@ async function getContributions() {
 }
 async function recordContribution(trackId, contribution) {
   const store = await load();
-  store[trackId] = contribution;
+  const existing = store[trackId] ?? [];
+  if (existing.some((c) => c.contributionId === contribution.contributionId)) {
+    return;
+  }
+  store[trackId] = [...existing, contribution];
   await save(store);
 }
+function latestContribution(store, trackId) {
+  const list = store[trackId];
+  if (!list || list.length === 0) return null;
+  return list.reduce((a, b) => b.sequenceNumber > a.sequenceNumber ? b : a);
+}
+function roundCount(store, trackId) {
+  return store[trackId]?.length ?? 0;
+}
 
 // src/components/Header.tsx
 import { Box, Text } from "ink";
@@ -337,7 +373,32 @@ var COMPUTING_MESSAGES = [
   "applying tau locally",
   "folding contribution proof",
   "blinding the trapdoor",
-  "sealing the bellman response"
+  "sealing the bellman response",
+  "asking the curve where it lives",
+  "weaving G1 points into the new delta",
+  "negotiating with the pairing engine",
+  "rotating the keypair commitment",
+  "checking that tau is non-zero (just in case)",
+  "evaluating polynomials over your secret",
+  "scrubbing the entropy buffer mid-flight",
+  "ratifying the contribution sequence",
+  "computing s \xB7 \u03C4 in G1",
+  "computing t \xB7 \u03C4 in G2",
+  "running the signature-of-knowledge",
+  "binding the transcript to your contribution",
+  "double-checking nothing is at infinity",
+  "compressing the response footprint",
+  "verifying your math one more time",
+  "stamping the public key bundle",
+  "writing the response file to disk",
+  "preparing to hand the response back to the worker",
+  "almost done \u2014 finalising your tau",
+  "this is the cryptography working hard for you",
+  "your secret never leaves this machine",
+  "if your power-21 circuit feels slow, blame BN254",
+  "snarkjs is single-threaded, give it a moment",
+  "trusted setup ceremonies are a team sport",
+  "the worker will verify everything you did"
 ];
 var VERIFYING_MESSAGES = [
   "worker pulling your response from S3",
@@ -346,20 +407,75 @@ var VERIFYING_MESSAGES = [
   "writing the next zkey",
   "uploading the new zkey",
   "anchoring contribution hash in the audit chain",
-  "almost there \u2014 finalising your receipt"
+  "almost there \u2014 finalising your receipt",
+  "parsing your response's wire format",
+  "validating every G1 point is on the curve",
+  "validating every G2 point is in the right subgroup",
+  "rebuilding the transcript hash chain",
+  "running the knowledge proof pairing",
+  "verifying the new delta_g1 matches its evidence",
+  "verifying the new delta_g2 matches its evidence",
+  "checking the L array against your contribution",
+  "checking the H array against your contribution",
+  "deriving Fiat-Shamir scalars for the batched check",
+  "running the random-linear-combination same-ratio",
+  "confirming the vKey fields were not altered",
+  "sequencing the new zkey for the next contributor",
+  "this is the part where every byte gets re-checked",
+  "soundness of the whole ceremony rides on this step",
+  "exporting the new bellman params for the next round",
+  "writing your contribution into the ceremony transcript",
+  "publishing the new audit chain entry",
+  "any tampering would have failed by now",
+  "if you see this, your contribution is provably honest",
+  "computing your contribution receipt",
+  "the math agrees \u2014 wrapping things up",
+  "finalising the verified state in Postgres",
+  "you did the cryptographic work \u2014 we just had to check"
 ];
 var EXPORTING_MESSAGES = [
   "preparing your challenge file",
   "extracting bellman params from the current zkey",
   "wrapping the zkey for handoff",
   "stamping a sha256 over the challenge bundle",
-  "presigning your download URL"
+  "presigning your download URL",
+  "fetching the latest verified state for this circuit",
+  "downloading the previous contribution from S3",
+  "checking the previous contribution's hash",
+  "carving out a personal challenge for your tau",
+  "the worker is queuing your slot",
+  "uploading the challenge so you can download it",
+  "rotating the worker's S3 connection",
+  "binding your challenge to the audit chain",
+  "stamping the challenge metadata in Postgres",
+  "AWS SDK is recycling connection pools",
+  "your slot timer starts the moment this finishes",
+  "writing the challenge to a fresh S3 key",
+  "double-checking the integrity hash",
+  "if this takes >1 min, S3 is having a bad time",
+  "Fargate is parsing the current bellman params",
+  "verifying the previous contribution's chain link",
+  "this step has no contributor-side analogue",
+  "the worker does the boring work so you don't have to",
+  "any second now \u2014 challenge is almost ready",
+  "encoding the challenge in Bellman wire format",
+  "making sure the file size matches the spec",
+  "presign URL is signed for 1 hour",
+  "your download will be tamper-evident",
+  "the challenge SHA-256 will be on the public transcript",
+  "patience \u2014 this is the longest server-side step",
+  "almost there \u2014 your turn is moments away"
 ];
 
 // src/components/QueueView.tsx
 import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var POLL_FAST_MS = 5e3;
 var POLL_SLOW_MS = 15e3;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "timed_out",
+  "failed",
+  "verified"
+]);
 function QueueView({ ceremonyId: ceremonyId2, trackId, token, onReady, onError }) {
   const [status, setStatus] = useState2(null);
   const [pollErr, setPollErr] = useState2(null);
@@ -381,6 +497,9 @@ function QueueView({ ceremonyId: ceremonyId2, trackId, token, onReady, onError }
           onReady(s);
           return;
         }
+        if (TERMINAL_STATUSES.has(s.status)) {
+          return;
+        }
         const interval = s.queue_position <= 2 ? POLL_FAST_MS : POLL_SLOW_MS;
         timeoutRef.current = setTimeout(poll, interval);
       } catch (err) {
@@ -406,43 +525,55 @@ function QueueView({ ceremonyId: ceremonyId2, trackId, token, onReady, onError }
       ] })
     ] });
   }
+  if (TERMINAL_STATUSES.has(status.status)) {
+    return /* @__PURE__ */ jsx2(TerminalSlotMessage, { status: status.status });
+  }
   const waitMins = Math.ceil((status.estimated_wait_secs ?? 0) / 60);
   const expiresAt = status.slot_expires_at ? new Date(status.slot_expires_at).toLocaleTimeString([], {
     hour: "2-digit",
     minute: "2-digit"
   }) : null;
   const fastPoll = status.queue_position <= 2;
+  const aheadCount = Math.max(0, status.queue_position - 1);
+  const peopleWord = aheadCount === 1 ? "person" : "people";
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
     /* @__PURE__ */ jsxs2(Box2, { gap: 2, children: [
-      /* @__PURE__ */ jsxs2(Text2, { children: [
-        "Position",
+      aheadCount === 0 ? /* @__PURE__ */ jsxs2(Text2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { bold: true, color: "green", children: "You're next" }),
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " in line" })
+      ] }) : /* @__PURE__ */ jsxs2(Text2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { bold: true, color: "yellow", children: aheadCount }),
         " ",
-        /* @__PURE__ */ jsx2(Text2, { bold: true, color: "yellow", children: status.queue_position }),
-        status.queue_depth > 0 && /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-          " of ",
-          status.queue_depth
+        peopleWord,
+        " ahead of you"
+      ] }),
+      status.queue_depth > 1 && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+        /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\xB7" }),
+        /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+          status.queue_depth,
+          " in queue"
         ] })
       ] }),
       /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\xB7" }),
       /* @__PURE__ */ jsxs2(Text2, { children: [
         "Estimated wait:",
         " ",
-        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: "cyan", children: [
-          "~",
-          waitMins,
-          " min"
-        ] })
+        /* @__PURE__ */ jsx2(Text2, { bold: true, color: "cyan", children: aheadCount === 0 ? "any moment now" : `~${waitMins} min` })
       ] })
     ] }),
-    status.status === "exporting" || status.status === "your_turn" || status.status === "ready_to_download" ? /* @__PURE__ */ jsx2(ExportingMessage, { status: status.status }) : status.active_since ? /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    status.status === "exporting" || status.status === "your_turn" || status.status === "ready_to_download" ? /* @__PURE__ */ jsx2(ExportingMessage, { status: status.status, slotExpiresAt: expiresAt }) : status.active_since ? /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
       "Another contributor is active",
       expiresAt ? ` \xB7 slot expires at ${expiresAt}` : ""
-    ] }) }) : status.queue_position > 1 ? (
+    ] }) }) : aheadCount > 0 ? (
       // Slot is idle but people are ahead — they joined and left without releasing.
       // timeout_watchdog will clear each stale slot after contribution_timeout_secs.
-      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Slot is idle \u2014 waiting for positions ahead to respond or time out (up to ~5 min each)" })
+      /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+        "Slot is idle \u2014 waiting for ",
+        peopleWord,
+        " ahead to respond or time out (up to ~5 min each)"
+      ] })
     ) : (
-      // Position 1, slot idle — advance_queue should fire shortly.
+      // At the front of the line, slot idle — advance_queue should fire shortly.
       /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Slot is idle \u2014 your turn is being prepared..." })
     ),
     pollErr ? /* @__PURE__ */ jsxs2(Text2, { color: "red", children: [
@@ -458,25 +589,63 @@ function QueueView({ ceremonyId: ceremonyId2, trackId, token, onReady, onError }
     ] })
   ] });
 }
-function ExportingMessage({ status }) {
+function TerminalSlotMessage({ status }) {
+  const lines = {
+    timed_out: {
+      headline: "Your slot expired before the challenge file was ready.",
+      detail: "This is usually a transient S3 hiccup on the worker side, not a problem with your machine. Press B or Backspace to return to the track list and rejoin the queue \u2014 it almost always succeeds the second time."
+    },
+    failed: {
+      headline: "The worker reported a failure on this contribution.",
+      detail: "Press B or Backspace to return to the track list. If this happens repeatedly on the same track, the admin needs to investigate."
+    },
+    verified: {
+      headline: "This contribution is already recorded as verified.",
+      detail: "Press B or Backspace to return to the track list and pick another track."
+    }
+  };
+  const key = status;
+  const msg = lines[key] ?? {
+    headline: `Contribution ended with status: ${status}.`,
+    detail: "Press B or Backspace to return to the track list."
+  };
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: "yellow", bold: true, children: msg.headline }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: msg.detail })
+  ] });
+}
+function ExportingMessage({
+  status,
+  slotExpiresAt
+}) {
   const exportingMsg = useCyclingMessage(EXPORTING_MESSAGES, 2500, status === "exporting");
-  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", children: status === "exporting" ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
-    /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
-      /* @__PURE__ */ jsx2(Spinner, { type: "dots" }),
-      " ",
-      exportingMsg,
-      "\u2026"
-    ] }),
-    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Your slot is active. The worker is preparing the challenge file just for you." })
-  ] }) : /* @__PURE__ */ jsx2(Text2, { color: "green", children: "Challenge ready \u2014 loading contribution flow\u2026" }) });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    status === "exporting" ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+        /* @__PURE__ */ jsx2(Spinner, { type: "dots" }),
+        " ",
+        exportingMsg,
+        "\u2026"
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Your slot is active. The worker is preparing the challenge file just for you." })
+    ] }) : /* @__PURE__ */ jsx2(Text2, { color: "green", children: "Challenge ready \u2014 loading contribution flow\u2026" }),
+    slotExpiresAt && // Visible countdown is critical on power-18 circuits where the
+    // contributor compute window can run several minutes — without
+    // this they have no way to tell if they're about to be reaped.
+    /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "Your slot expires at ",
+      slotExpiresAt,
+      " (server time)."
+    ] })
+  ] });
 }
 
-// src/components/EntropyCollector.tsx
-import { useRef as useRef2, useState as useState3 } from "react";
+// src/components/MouseEntropyCollector.tsx
+import { useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
 import { Box as Box3, Text as Text3, useInput } from "ink";
 
 // src/entropy.ts
-import { createHash as createHash2, randomBytes } from "crypto";
+import { createHash as createHash2, hkdfSync, randomBytes } from "crypto";
 function sha512(buf) {
   return createHash2("sha512").update(buf).digest();
 }
@@ -488,18 +657,405 @@ function buildEntropyFromKeystrokes(chars, timingsNs) {
   const osHash = sha512(randomBytes(64));
   return createHash2("sha512").update(keystrokeHash).update(osHash).digest("hex");
 }
+var TRAIL_MIN_BYTES = 64;
+function buildEntropyFromMouseTrail(strokes) {
+  const strokeBuf = Buffer.alloc(strokes.length * 12);
+  for (let i = 0; i < strokes.length; i++) {
+    const s = strokes[i];
+    strokeBuf.writeUInt16BE(s.x & 65535, i * 12);
+    strokeBuf.writeUInt16BE(s.y & 65535, i * 12 + 2);
+    strokeBuf.writeBigUInt64BE(s.dtNs, i * 12 + 4);
+  }
+  const padBytes = Math.max(0, TRAIL_MIN_BYTES - strokeBuf.length);
+  const trailInput = padBytes > 0 ? Buffer.concat([strokeBuf, randomBytes(padBytes)]) : strokeBuf;
+  const trailHash = sha512(trailInput);
+  const osHash = sha512(randomBytes(64));
+  return createHash2("sha512").update(trailHash).update(osHash).digest("hex");
+}
+function deriveCircuitEntropy(masterSeed, ceremonyId2, circuitName) {
+  const ikm = Buffer.from(masterSeed, "hex");
+  const salt = createHash2("sha256").update(ceremonyId2).digest();
+  const info = Buffer.from(`umbra-ceremony-${ceremonyId2}-circuit-${circuitName}`, "utf8");
+  const derived = Buffer.from(hkdfSync("sha512", ikm, salt, info, 64));
+  return derived.toString("hex");
+}
 
-// src/components/EntropyCollector.tsx
+// src/mouse.ts
+var SGR_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+function classifyButton(buttonCode) {
+  if (buttonCode & 32) return "motion";
+  const base = buttonCode & 3;
+  if (base === 0) return "left";
+  if (base === 1) return "middle";
+  if (base === 2) return "right";
+  return "other";
+}
+function parseMouseChunk(chunk) {
+  const s = typeof chunk === "string" ? chunk : chunk.toString("binary");
+  const events = [];
+  SGR_RE.lastIndex = 0;
+  let m;
+  while ((m = SGR_RE.exec(s)) !== null) {
+    const buttonCode = parseInt(m[1], 10);
+    const col = parseInt(m[2], 10) - 1;
+    const row = parseInt(m[3], 10) - 1;
+    events.push({
+      button: classifyButton(buttonCode),
+      col,
+      row,
+      isRelease: m[4] === "m"
+    });
+  }
+  return events;
+}
+function enableMouseReporting() {
+  process.stdout.write("\x1B[?1003h\x1B[?1006h");
+  return () => {
+    process.stdout.write("\x1B[?1003l\x1B[?1006l");
+  };
+}
+
+// src/components/MouseEntropyCollector.tsx
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var LEFT_OFFSET = 1;
+var TOP_OFFSET = 2;
+var MIN_W = 18;
+var MIN_H = 12;
+var MAX_W = 80;
+var MAX_H = 32;
+var DEFAULT_ASPECT = 2.2;
+var ASPECT = (() => {
+  const raw = process.env["CEREMONY_CANVAS_ASPECT"];
+  if (!raw) return DEFAULT_ASPECT;
+  const parsed = Number.parseFloat(raw);
+  if (!Number.isFinite(parsed) || parsed < 0.5 || parsed > 6) return DEFAULT_ASPECT;
+  return parsed;
+})();
+var CHROME_ROWS = 6;
+var CHROME_COLS = 2;
+var MIN_ELAPSED_MS = 3e3;
+var RENDER_INTERVAL_MS = 33;
+function deriveCanvasSize(cols, rows) {
+  const availH = rows - CHROME_ROWS;
+  const availW = cols - CHROME_COLS;
+  let h = Math.min(MAX_H, availH);
+  let w = Math.round(h * ASPECT);
+  const wCap = Math.min(MAX_W, availW);
+  if (w > wCap) {
+    w = wCap;
+    h = Math.round(w / ASPECT);
+  }
+  if (w < MIN_W || h < MIN_H) return null;
+  return { w, h };
+}
+function readTerminalDims() {
+  return {
+    cols: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24
+  };
+}
+function MouseEntropyCollector({ title, onComplete, onError }) {
+  const [dims, setDims] = useState3(() => {
+    const { cols, rows } = readTerminalDims();
+    return deriveCanvasSize(cols, rows);
+  });
+  const dimsRef = useRef2(dims);
+  useEffect3(() => {
+    dimsRef.current = dims;
+  }, [dims]);
+  const pixelsRef = useRef2(/* @__PURE__ */ new Set());
+  const strokesRef = useRef2([]);
+  const mouseDownRef = useRef2(false);
+  const lastPaintRef = useRef2(null);
+  const cursorRef = useRef2(null);
+  const lastStrokeTsRef = useRef2(process.hrtime.bigint());
+  const startTsRef = useRef2(process.hrtime.bigint());
+  const completedRef = useRef2(false);
+  const [pixelCount, setPixelCount] = useState3(0);
+  const [elapsedMs, setElapsedMs] = useState3(0);
+  const [done, setDone] = useState3(false);
+  const [nudge, setNudge] = useState3(null);
+  const [grid, setGrid] = useState3(
+    () => dims ? Array.from({ length: dims.h }, () => " ".repeat(dims.w)) : []
+  );
+  const [cursor, setCursor] = useState3(null);
+  const canvasW = dims?.w ?? 0;
+  const canvasH = dims?.h ?? 0;
+  const subH = canvasH * 2;
+  function idx(x, y) {
+    return y * canvasW + x;
+  }
+  function paintLine(pixels, x0, y0, x1, y1, onNew) {
+    let dx = Math.abs(x1 - x0);
+    let dy = -Math.abs(y1 - y0);
+    const sx = x0 < x1 ? 1 : -1;
+    const sy = y0 < y1 ? 1 : -1;
+    let err = dx + dy;
+    let x = x0;
+    let y = y0;
+    while (true) {
+      if (x >= 0 && x < canvasW && y >= 0 && y < subH) {
+        const id = idx(x, y);
+        if (!pixels.has(id)) {
+          pixels.add(id);
+          onNew(x, y);
+        }
+      }
+      if (x === x1 && y === y1) break;
+      const e2 = 2 * err;
+      if (e2 >= dy) {
+        if (x === x1) break;
+        err += dy;
+        x += sx;
+      }
+      if (e2 <= dx) {
+        if (y === y1) break;
+        err += dx;
+        y += sy;
+      }
+    }
+  }
+  useEffect3(() => {
+    const onResize = () => {
+      const { cols, rows } = readTerminalDims();
+      const next = deriveCanvasSize(cols, rows);
+      const cur = dimsRef.current;
+      if (next === null && cur === null) return;
+      if (next !== null && cur !== null && next.w === cur.w && next.h === cur.h) return;
+      pixelsRef.current.clear();
+      strokesRef.current = [];
+      lastPaintRef.current = null;
+      cursorRef.current = null;
+      startTsRef.current = process.hrtime.bigint();
+      lastStrokeTsRef.current = startTsRef.current;
+      setNudge(null);
+      setPixelCount(0);
+      setElapsedMs(0);
+      setCursor(null);
+      setGrid(next ? Array.from({ length: next.h }, () => " ".repeat(next.w)) : []);
+      setDims(next);
+    };
+    process.stdout.on("resize", onResize);
+    return () => {
+      process.stdout.off("resize", onResize);
+    };
+  }, []);
+  useEffect3(() => {
+    if (!dims) return;
+    const disableMouse = enableMouseReporting();
+    const onData = (chunk) => {
+      if (completedRef.current) return;
+      const events = parseMouseChunk(chunk);
+      for (const ev of events) handleMouseEvent(ev);
+    };
+    process.stdin.on("data", onData);
+    const renderTick = setInterval(() => {
+      if (completedRef.current) return;
+      const size = pixelsRef.current.size;
+      const elapsed = Number((process.hrtime.bigint() - startTsRef.current) / 1000000n);
+      if (size !== pixelCount) setPixelCount(size);
+      if (elapsed !== elapsedMs) setElapsedMs(elapsed);
+      const next = [];
+      for (let r = 0; r < canvasH; r++) {
+        let line = "";
+        for (let c = 0; c < canvasW; c++) {
+          const top = pixelsRef.current.has(idx(c, r * 2));
+          const bot = pixelsRef.current.has(idx(c, r * 2 + 1));
+          line += top && bot ? "\u2588" : top ? "\u2580" : bot ? "\u2584" : " ";
+        }
+        next.push(line);
+      }
+      setGrid(next);
+      setCursor(cursorRef.current);
+    }, RENDER_INTERVAL_MS);
+    return () => {
+      clearInterval(renderTick);
+      process.stdin.off("data", onData);
+      disableMouse();
+    };
+  }, [canvasW, canvasH]);
+  function handleMouseEvent(ev) {
+    if (completedRef.current) return;
+    const canvasCol = ev.col - LEFT_OFFSET;
+    const canvasRow = ev.row - TOP_OFFSET;
+    const inBounds = canvasCol >= 0 && canvasCol < canvasW && canvasRow >= 0 && canvasRow < canvasH;
+    if (inBounds) cursorRef.current = { row: canvasRow, col: canvasCol };
+    else cursorRef.current = null;
+    if (ev.button === "left" && !ev.isRelease) {
+      mouseDownRef.current = true;
+      lastPaintRef.current = null;
+      if (inBounds) paintAt(canvasCol, canvasRow);
+      return;
+    }
+    if (ev.isRelease) {
+      mouseDownRef.current = false;
+      lastPaintRef.current = null;
+      return;
+    }
+    if (ev.button === "motion" && mouseDownRef.current && inBounds) {
+      paintAt(canvasCol, canvasRow);
+    }
+  }
+  function paintAt(canvasCol, canvasRow) {
+    const x = canvasCol;
+    const yTop = canvasRow * 2;
+    const yBot = canvasRow * 2 + 1;
+    const now = process.hrtime.bigint();
+    const dt = now - lastStrokeTsRef.current;
+    lastStrokeTsRef.current = now;
+    if (lastPaintRef.current) {
+      const lp = lastPaintRef.current;
+      paintLine(pixelsRef.current, lp.x, lp.y, x, yTop, (px, py) => {
+        strokesRef.current.push({ x: px, y: py, dtNs: dt });
+      });
+      paintLine(pixelsRef.current, lp.x, lp.y + 1, x, yBot, () => {
+      });
+    } else {
+      if (!pixelsRef.current.has(idx(x, yTop))) {
+        pixelsRef.current.add(idx(x, yTop));
+        strokesRef.current.push({ x, y: yTop, dtNs: dt });
+      }
+      if (!pixelsRef.current.has(idx(x, yBot))) {
+        pixelsRef.current.add(idx(x, yBot));
+      }
+    }
+    lastPaintRef.current = { x, y: yTop };
+  }
+  useInput((input, key) => {
+    if (completedRef.current) return;
+    if (key.backspace || key.delete || input === "c" || input === "C") {
+      pixelsRef.current.clear();
+      strokesRef.current = [];
+      lastPaintRef.current = null;
+      cursorRef.current = null;
+      startTsRef.current = process.hrtime.bigint();
+      lastStrokeTsRef.current = startTsRef.current;
+      setNudge(null);
+      return;
+    }
+    if (key.return) {
+      const elapsed = Number((process.hrtime.bigint() - startTsRef.current) / 1000000n);
+      if (elapsed < MIN_ELAPSED_MS) {
+        const secLeft = Math.ceil((MIN_ELAPSED_MS - elapsed) / 1e3);
+        setNudge(`Wait ${secLeft}s before committing (anti-fat-finger).`);
+        return;
+      }
+      completedRef.current = true;
+      setDone(true);
+      try {
+        const entropy = buildEntropyFromMouseTrail(strokesRef.current);
+        setTimeout(() => onComplete(entropy), 250);
+      } catch (e) {
+        onError(e instanceof Error ? e : new Error(String(e)));
+      }
+    }
+  });
+  if (!dims) {
+    const { cols, rows } = readTerminalDims();
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: "yellow", children: "\u26A0 Terminal too small for the mouse canvas" }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "Need at least ",
+        MIN_W + CHROME_COLS,
+        " cols \xD7 ",
+        MIN_H + CHROME_ROWS,
+        " rows. Got ",
+        cols,
+        " \xD7 ",
+        rows,
+        "."
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "Resize this window larger, or press ",
+        /* @__PURE__ */ jsx3(Text3, { bold: true, children: "\u232B Backspace" }),
+        " to go back and then ",
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: "magenta", children: "K" }),
+        " on the mode-select modal to use keyboard entropy instead."
+      ] })
+    ] });
+  }
+  const secsElapsed = Math.floor(elapsedMs / 1e3);
+  const minSecs = Math.ceil(MIN_ELAPSED_MS / 1e3);
+  const timePct = Math.min(100, Math.round(elapsedMs / MIN_ELAPSED_MS * 100));
+  const filled = Math.round(timePct / 100 * 20);
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(20 - filled);
+  const ready = elapsedMs >= MIN_ELAPSED_MS;
+  if (done) {
+    return /* @__PURE__ */ jsxs3(Box3, { gap: 2, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "\u2713" }),
+      /* @__PURE__ */ jsx3(Text3, { children: "Entropy committed." })
+    ] });
+  }
+  const renderRow = (rowStr, rowIdx) => {
+    if (!cursor || cursor.row !== rowIdx) {
+      return /* @__PURE__ */ jsx3(Text3, { color: "white", children: rowStr });
+    }
+    const cIdx = cursor.col;
+    const before = rowStr.slice(0, cIdx);
+    const at = rowStr[cIdx] ?? " ";
+    const after = rowStr.slice(cIdx + 1);
+    return /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "white", children: before }),
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", inverse: true, children: at === " " ? "\xB7" : at }),
+      /* @__PURE__ */ jsx3(Text3, { color: "white", children: after })
+    ] });
+  };
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text3, { children: title ? /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: title.length > 70 ? title.slice(0, 67) + "\u2026" : title }) : /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: "Draw to generate entropy \u2014 hold the LEFT mouse button and drag" }) }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "\u250C",
+      "\u2500".repeat(canvasW),
+      "\u2510"
+    ] }),
+    grid.map((row, i) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2502" }),
+      renderRow(row, i),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2502" })
+    ] }, i)),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "\u2514",
+      "\u2500".repeat(canvasW),
+      "\u2518"
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { gap: 2, children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: ready ? "green" : "cyan", children: [
+        "[",
+        bar,
+        "]"
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        /* @__PURE__ */ jsxs3(Text3, { bold: true, color: ready ? "green" : "yellow", children: [
+          secsElapsed,
+          "s"
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          " ",
+          "/ ",
+          minSecs,
+          "s \xB7 ",
+          pixelCount,
+          " pixels drawn"
+        ] })
+      ] }),
+      nudge && /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: nudge })
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Enter = commit \xB7 c / \u232B = clear \xB7 Ctrl+C / Ctrl+Z = abort" })
+  ] });
+}
+
+// src/components/EntropyCollector.tsx
+import { useRef as useRef3, useState as useState4 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 var TARGET = 20;
 function EntropyCollector({ onComplete, onError }) {
-  const [count, setCount] = useState3(0);
-  const [done, setDone] = useState3(false);
-  const charsRef = useRef2([]);
-  const timingsRef = useRef2([]);
-  const lastRef = useRef2(process.hrtime.bigint());
-  const completedRef = useRef2(false);
-  useInput((input) => {
+  const [count, setCount] = useState4(0);
+  const [done, setDone] = useState4(false);
+  const charsRef = useRef3([]);
+  const timingsRef = useRef3([]);
+  const lastRef = useRef3(process.hrtime.bigint());
+  const completedRef = useRef3(false);
+  useInput2((input) => {
     if (completedRef.current) return;
     const now = process.hrtime.bigint();
     timingsRef.current.push(now - lastRef.current);
@@ -523,32 +1079,32 @@ function EntropyCollector({ onComplete, onError }) {
   const pct = Math.round(count / TARGET * 100);
   const stars = "*".repeat(Math.min(count, 32));
   if (done) {
-    return /* @__PURE__ */ jsxs3(Box3, { gap: 2, children: [
-      /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "\u2713" }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
+    return /* @__PURE__ */ jsxs4(Box4, { gap: 2, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "green", bold: true, children: "\u2713" }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
         "Entropy collected \u2014 [",
         bar,
         "] 100%"
       ] })
     ] });
   }
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", gap: 1, children: [
-    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Type anything to generate entropy:" }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Keystroke timing (nanosecond intervals) is the randomness source." }),
-    /* @__PURE__ */ jsxs3(Box3, { marginTop: 1, children: [
-      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " > " }),
-      /* @__PURE__ */ jsx3(Text3, { color: "green", children: stars }),
-      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "\u2588" })
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Type anything to generate entropy:" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Keystroke timing (nanosecond intervals) is the randomness source." }),
+    /* @__PURE__ */ jsxs4(Box4, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: " > " }),
+      /* @__PURE__ */ jsx4(Text4, { color: "green", children: stars }),
+      /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "\u2588" })
     ] }),
-    /* @__PURE__ */ jsxs3(Box3, { gap: 2, marginTop: 1, children: [
-      /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+    /* @__PURE__ */ jsxs4(Box4, { gap: 2, marginTop: 1, children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "cyan", children: [
         "[",
         bar,
         "]"
       ] }),
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        /* @__PURE__ */ jsx3(Text3, { bold: true, color: count > 0 ? "green" : "yellow", children: count }),
-        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { bold: true, color: count > 0 ? "green" : "yellow", children: count }),
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
           "/",
           TARGET,
           " keystrokes (",
@@ -557,13 +1113,14 @@ function EntropyCollector({ onComplete, onError }) {
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Shown as * \u2014 your actual input is never revealed." })
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Shown as * \u2014 your actual input is never revealed." }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "To quit without contributing: Ctrl+C or Ctrl+Z (Q is part of the entropy alphabet here)." })
   ] });
 }
 
 // src/components/ContributeFlow.tsx
-import { useEffect as useEffect4, useState as useState4 } from "react";
-import { Box as Box4, Text as Text4 } from "ink";
+import { useEffect as useEffect5, useState as useState5 } from "react";
+import { Box as Box5, Text as Text5 } from "ink";
 import Spinner2 from "ink-spinner";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join4 } from "path";
@@ -590,7 +1147,7 @@ async function cleanupTemp(path) {
 }
 
 // src/components/ContributeFlow.tsx
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 var STEP_LABELS = ["downloading", "computing", "uploading", "signalling", "verifying"];
 var STEP_INDEX = {
   downloading: 0,
@@ -601,8 +1158,8 @@ var STEP_INDEX = {
 };
 function ContributeFlow(props) {
   const { ceremonyId: ceremonyId2, trackId, token, slotStatus, entropy, displayName: displayName2 } = props;
-  const [step, setStep] = useState4({ name: "downloading", bytesReceived: 0, total: null });
-  useEffect4(() => {
+  const [step, setStep] = useState5({ name: "downloading", bytesReceived: 0, total: null });
+  useEffect5(() => {
     let cancelled = false;
     const challengePath = join4(tmpdir2(), `ceremony-challenge-${Date.now()}.mpcparams`);
     let responsePath = null;
@@ -685,112 +1242,138 @@ function ContributeFlow(props) {
   const currentIdx = STEP_INDEX[step.name] ?? 0;
   const computingMsg = useCyclingMessage(COMPUTING_MESSAGES, 2500, step.name === "computing");
   const verifyingMsg = useCyclingMessage(VERIFYING_MESSAGES, 3e3, step.name === "verifying");
-  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", gap: 1, children: STEP_LABELS.map((label, i) => {
-    const isDone = i < currentIdx;
-    const isActive = i === currentIdx;
-    const isPending = i > currentIdx;
-    let indicator;
-    if (isDone) indicator = /* @__PURE__ */ jsx4(Text4, { color: "green", children: "\u2713" });
-    else if (isActive) indicator = /* @__PURE__ */ jsx4(Spinner2, { type: "dots" });
-    else indicator = /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "\u25CB" });
-    let detail = null;
-    if (isActive && step.name === "downloading" && step.total) {
-      const pct = Math.round(step.bytesReceived / step.total * 100);
-      const filled = Math.round(pct / 5);
-      const bar = "\u2588".repeat(filled) + "\u2591".repeat(20 - filled);
-      detail = /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-        " ",
-        "[",
-        bar,
-        "] ",
-        pct,
-        "%"
-      ] });
-    }
-    if (isActive && step.name === "verifying") {
-      const elapsed = step.attempt <= 10 ? step.attempt * 3 : 10 * 3 + (step.attempt - 10) * 10;
-      const mins = Math.floor(elapsed / 60);
-      const secs = elapsed % 60;
-      const time = mins > 0 ? `${mins}m ${secs.toString().padStart(2, "0")}s` : `${secs}s`;
-      detail = /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
-        " ",
-        verifyingMsg,
-        "\u2026 (",
-        time,
-        " elapsed)"
-      ] });
-    }
-    if (isActive && step.name === "computing") {
-      detail = /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", gap: 1, children: [
+    STEP_LABELS.map((label, i) => {
+      const isDone = i < currentIdx;
+      const isActive = i === currentIdx;
+      const isPending = i > currentIdx;
+      let indicator;
+      if (isDone) indicator = /* @__PURE__ */ jsx5(Text5, { color: "green", children: "\u2713" });
+      else if (isActive) indicator = /* @__PURE__ */ jsx5(Spinner2, { type: "dots" });
+      else indicator = /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u25CB" });
+      let detail = null;
+      if (isActive && step.name === "downloading" && step.total) {
+        const pct = Math.round(step.bytesReceived / step.total * 100);
+        const filled = Math.round(pct / 5);
+        const bar = "\u2588".repeat(filled) + "\u2591".repeat(20 - filled);
+        detail = /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          " ",
+          "[",
+          bar,
+          "] ",
+          pct,
+          "%"
+        ] });
+      }
+      if (isActive && step.name === "verifying") {
+        const elapsed = step.attempt <= 10 ? step.attempt * 3 : 10 * 3 + (step.attempt - 10) * 10;
+        const mins = Math.floor(elapsed / 60);
+        const secs = elapsed % 60;
+        const time = mins > 0 ? `${mins}m ${secs.toString().padStart(2, "0")}s` : `${secs}s`;
+        detail = /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          " ",
+          verifyingMsg,
+          "\u2026 (",
+          time,
+          " elapsed)"
+        ] });
+      }
+      if (isActive && step.name === "computing") {
+        detail = /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+          " ",
+          computingMsg,
+          "\u2026"
+        ] });
+      }
+      return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
+          indicator,
+          /* @__PURE__ */ jsxs5(
+            Text5,
+            {
+              color: isDone ? "green" : isActive ? "white" : void 0,
+              bold: isActive,
+              dimColor: isPending,
+              children: [
+                label.charAt(0).toUpperCase() + label.slice(1),
+                " ",
+                isActive && label === "computing" && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "(entropy stays local)" })
+              ]
+            }
+          )
+        ] }),
+        detail
+      ] }, label);
+    }),
+    slotStatus.slot_expires_at && step.name !== "verifying" && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+      "Your slot expires at",
+      " ",
+      new Date(slotStatus.slot_expires_at).toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit"
+      }),
+      " ",
+      "(server time)."
+    ] }) }),
+    /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+      /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+        "Need to bail? Press",
         " ",
-        computingMsg,
-        "\u2026"
-      ] });
-    }
-    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs4(Box4, { gap: 2, children: [
-        indicator,
-        /* @__PURE__ */ jsxs4(
-          Text4,
-          {
-            color: isDone ? "green" : isActive ? "white" : void 0,
-            bold: isActive,
-            dimColor: isPending,
-            children: [
-              label.charAt(0).toUpperCase() + label.slice(1),
-              " ",
-              isActive && label === "computing" && /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "(entropy stays local)" })
-            ]
-          }
-        )
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Q" }),
+        ", ",
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Ctrl+C" }),
+        ", or ",
+        /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Ctrl+Z" }),
+        " \u2014 your slot is released immediately so the next contributor can take over."
       ] }),
-      detail
-    ] }, label);
-  }) });
+      step.name === "computing" && /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "(During this step snarkjs is busy \u2014 Ctrl+C / Ctrl+Z respond faster than Q.)" })
+    ] })
+  ] });
 }
 
 // src/components/Attestation.tsx
-import { Box as Box5, Text as Text5 } from "ink";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 function Attestation({ contribution }) {
   const hashShort = contribution.contributionHash ? `${contribution.contributionHash.slice(0, 16)}...${contribution.contributionHash.slice(-8)}` : "(pending verification)";
   const verifiedAt = contribution.verifiedAt ? new Date(contribution.verifiedAt).toLocaleString() : null;
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", gap: 1, children: [
-    /* @__PURE__ */ jsx5(Text5, { bold: true, color: "green", children: "\u2713 Contribution verified!" }),
-    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", gap: 0, children: [
-      /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Circuit" }),
-        /* @__PURE__ */ jsx5(Text5, { bold: true, children: contribution.circuitName })
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, color: "green", children: "\u2713 Contribution verified!" }),
+    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", gap: 0, children: [
+      /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Circuit" }),
+        /* @__PURE__ */ jsx6(Text6, { bold: true, children: contribution.circuitName })
       ] }),
-      /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Round " }),
-        /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+      /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Round " }),
+        /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
           "#",
           contribution.sequenceNumber
         ] })
       ] }),
-      /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Hash " }),
-        /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: hashShort })
+      /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Hash " }),
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", children: hashShort })
       ] }),
-      verifiedAt && /* @__PURE__ */ jsxs5(Box5, { gap: 2, children: [
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Time " }),
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: verifiedAt })
+      verifiedAt && /* @__PURE__ */ jsxs6(Box6, { gap: 2, children: [
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Time " }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: verifiedAt })
       ] })
     ] }),
-    contribution.contributionHash && /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "Full hash (share this to prove participation):" }),
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", wrap: "wrap", children: contribution.contributionHash })
+    contribution.contributionHash && /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Full hash (share this to prove participation):" }),
+      /* @__PURE__ */ jsx6(Text6, { color: "cyan", wrap: "wrap", children: contribution.contributionHash })
     ] })
   ] });
 }
 
 // src/components/InfoModal.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 function InfoModal() {
-  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", paddingX: 2, paddingY: 1, children: /* @__PURE__ */ jsxs6(
-    Box6,
+  return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", paddingX: 2, paddingY: 1, children: /* @__PURE__ */ jsxs7(
+    Box7,
     {
       flexDirection: "column",
       borderStyle: "round",
@@ -800,34 +1383,66 @@ function InfoModal() {
       width: 84,
       gap: 1,
       children: [
-        /* @__PURE__ */ jsx6(Text6, { bold: true, color: "cyan", children: "Umbra Phase 2 Trusted-Setup Ceremony" }),
-        /* @__PURE__ */ jsx6(Text6, { children: "Umbra uses Groth16 zero-knowledge proofs to give Solana users on-chain privacy. Every circuit needs a one-time multi-party ceremony to generate its proving key safely \u2014 that is Phase 2. Each contributor adds their own secret entropy and destroys it afterward. The setup stays secure as long as AT LEAST ONE contributor erased theirs, which is why your single contribution genuinely matters." }),
-        /* @__PURE__ */ jsx6(Text6, { children: "What you will do: tap 20 keys to seed your entropy, download the latest challenge file, run snarkjs locally to combine your secret with the parameters, and upload the response. Your secret never leaves your machine. Erase it when you are done." }),
-        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Press B, Esc or ? to close" })
+        /* @__PURE__ */ jsx7(Text7, { bold: true, color: "cyan", children: "Umbra Phase 2 Trusted-Setup Ceremony" }),
+        /* @__PURE__ */ jsx7(Text7, { children: "Umbra uses Groth16 zero-knowledge proofs to give Solana users on-chain privacy. Every circuit needs a one-time multi-party ceremony to generate its proving key safely \u2014 that is Phase 2. Each contributor adds their own secret entropy and destroys it afterward. The setup stays secure as long as AT LEAST ONE contributor erased theirs, which is why your single contribution genuinely matters." }),
+        /* @__PURE__ */ jsx7(Text7, { children: "What you will do: tap 20 keys to seed your entropy, download the latest challenge file, run snarkjs locally to combine your secret with the parameters, and upload the response. Your secret never leaves your machine. Erase it when you are done." }),
+        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Press B, Esc or ? to close" })
       ]
     }
   ) });
 }
 
 // src/components/App.tsx
-import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
 var NAME_MAX_LEN = 100;
 var NAME_VALID_RE = /^[\p{L}\p{N} _.\-]*$/u;
+function elideMiddle(s, maxLen) {
+  if (s.length <= maxLen) return s;
+  const keepHead = Math.ceil((maxLen - 1) / 2);
+  const keepTail = Math.floor((maxLen - 1) / 2);
+  return s.slice(0, keepHead) + "\u2026" + s.slice(s.length - keepTail);
+}
+function orderTracksForAuto(tracks, contributed) {
+  const openTracks = tracks.filter((t) => t.status === "open");
+  const fresh = [];
+  const alreadyDone = [];
+  for (const t of openTracks) {
+    if ((contributed[t.id]?.length ?? 0) > 0) alreadyDone.push(t);
+    else fresh.push(t);
+  }
+  return [...fresh, ...alreadyDone];
+}
+function copyToClipboardOSC52(value) {
+  const payload = Buffer.from(value, "utf8").toString("base64");
+  process.stdout.write(`\x1B]52;c;${payload}\x07`);
+}
 function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName }) {
   const { exit } = useApp();
-  const [activeCeremonyId, setActiveCeremonyId] = useState5(initialCeremonyId);
-  const [displayName2, setDisplayName] = useState5(initialDisplayName ?? "anonymous");
-  const [nameSet, setNameSet] = useState5(initialDisplayName !== void 0);
-  const [screen, setScreen] = useState5(
+  const [activeCeremonyId, setActiveCeremonyId] = useState6(initialCeremonyId);
+  const [displayName2, setDisplayName] = useState6(initialDisplayName ?? "anonymous");
+  const [nameSet, setNameSet] = useState6(initialDisplayName !== void 0);
+  const [screen, setScreenRaw] = useState6(
     initialDisplayName === void 0 ? { name: "name-input", value: "" } : initialCeremonyId ? { name: "loading" } : { name: "ceremony-picker", ceremonies: [], loading: true }
   );
-  const [ceremony, setCeremony] = useState5(null);
-  const [session, setSession] = useState5(null);
-  const [contributed, setContributed] = useState5({});
-  const [selectedIdx, setSelectedIdx] = useState5(0);
-  const [tab, setTab] = useState5(0);
-  const [showInfo, setShowInfo] = useState5(false);
-  useEffect5(() => {
+  const setScreen = (next) => {
+    setScreenRaw((prev) => {
+      const resolved = typeof next === "function" ? next(prev) : next;
+      if (prev.name !== resolved.name) {
+        process.stdout.write("\x1B[2J\x1B[H");
+      }
+      return resolved;
+    });
+  };
+  const [ceremony, setCeremony] = useState6(null);
+  const [session, setSession] = useState6(null);
+  const [contributed, setContributed] = useState6({});
+  const [selectedIdx, setSelectedIdx] = useState6(0);
+  const [tab, setTab] = useState6(0);
+  const [contribCursor, setContribCursor] = useState6(0);
+  const [copyToast, setCopyToast] = useState6(null);
+  const [showInfo, setShowInfo] = useState6(false);
+  const [entropyMode, setEntropyMode] = useState6("mouse");
+  useEffect6(() => {
     if (!nameSet) return;
     if (!initialCeremonyId) {
       loadCeremonies();
@@ -875,7 +1490,7 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
         return;
       }
       setSelectedIdx(0);
-      setScreen({ name: "tracks", tracks });
+      setScreen({ name: "mode-select", tracks });
     } catch (e) {
       if (e.code === "INVALID_SESSION" || e.status === 401) {
         try {
@@ -892,7 +1507,7 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
             return;
           }
           setSelectedIdx(0);
-          setScreen({ name: "tracks", tracks });
+          setScreen({ name: "mode-select", tracks });
         } catch (e2) {
           setScreen({
             name: "error",
@@ -950,9 +1565,25 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
     setScreen({ name: "ceremony-picker", ceremonies: [], loading: true });
     loadCeremonies();
   }
-  useEffect5(() => {
-    if (screen.name === "queue" && session) {
-      const { trackId } = screen;
+  useEffect6(() => {
+    if (session) {
+      setSessionCleanup(clearSession);
+    } else {
+      clearSessionCleanup();
+    }
+  }, [session]);
+  useEffect6(() => {
+    let trackId = null;
+    if (screen.name === "queue" || screen.name === "entropy" || screen.name === "contribute") {
+      trackId = screen.trackId;
+    } else if (screen.name === "auto-running") {
+      if (screen.subPhase.kind === "waiting" || screen.subPhase.kind === "contributing" || screen.subPhase.kind === "releasing") {
+        trackId = screen.subPhase.trackId;
+      } else if (screen.current) {
+        trackId = screen.current.id;
+      }
+    }
+    if (trackId && session) {
       setQueueCleanup(() => {
         api.leaveQueue(activeCeremonyId, trackId, session.session_token).catch(() => {
         });
@@ -960,8 +1591,69 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
     } else {
       clearQueueCleanup();
     }
-  }, [screen.name]);
-  useInput2((input, key) => {
+  }, [screen.name, screen.name === "auto-running" ? screen.subPhase.kind : null]);
+  useEffect6(() => {
+    if (screen.name !== "auto-running") return;
+    if (screen.current !== null) return;
+    if (screen.subPhase.kind !== "queueing") return;
+    if (!session) return;
+    const currentScreen = screen;
+    (async () => {
+      let next = null;
+      let nextRemaining = currentScreen.remaining;
+      let nextRetryQueue = currentScreen.retryQueue;
+      let nextRetryingPhase = currentScreen.retryingPhase;
+      if (currentScreen.remaining.length > 0) {
+        next = currentScreen.remaining[0];
+        nextRemaining = currentScreen.remaining.slice(1);
+      } else if (currentScreen.retryQueue.length > 0 && !currentScreen.retryingPhase) {
+        nextRemaining = currentScreen.retryQueue.slice(1);
+        next = currentScreen.retryQueue[0];
+        nextRetryQueue = [];
+        nextRetryingPhase = true;
+      }
+      if (!next) {
+        setScreen({ name: "auto-summary", outcomes: currentScreen.done });
+        return;
+      }
+      try {
+        await api.joinQueue(activeCeremonyId, next.id, session.session_token);
+      } catch (e) {
+        const reason = e?.message ?? String(e);
+        setScreen({
+          ...currentScreen,
+          remaining: nextRemaining,
+          retryQueue: nextRetryQueue,
+          retryingPhase: nextRetryingPhase,
+          current: null,
+          subPhase: { kind: "queueing" },
+          done: [
+            ...currentScreen.done,
+            {
+              trackId: next.id,
+              circuitName: next.circuit_name,
+              result: "failed",
+              reason: `joinQueue: ${reason}`
+            }
+          ]
+        });
+        return;
+      }
+      setScreen({
+        ...currentScreen,
+        remaining: nextRemaining,
+        retryQueue: nextRetryQueue,
+        retryingPhase: nextRetryingPhase,
+        current: next,
+        subPhase: { kind: "waiting", trackId: next.id, circuitName: next.circuit_name }
+      });
+    })();
+  }, [
+    screen.name,
+    screen.name === "auto-running" ? screen.subPhase.kind : null,
+    screen.name === "auto-running" ? screen.current?.id ?? null : null
+  ]);
+  useInput3((input, key) => {
     const q = input.toLowerCase();
     if (showInfo) {
       if (key.escape || input === "?" || q === "b") {
@@ -974,7 +1666,7 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
       }
       return;
     }
-    if (input === "?" && screen.name !== "entropy") {
+    if (input === "?" && screen.name !== "entropy" && screen.name !== "auto-entropy") {
       setShowInfo(true);
       return;
     }
@@ -1001,23 +1693,84 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
       }
       return;
     }
-    if (q === "q" && screen.name !== "entropy") {
-      if (screen.name === "queue" && session) {
+    if (q === "q" && screen.name !== "entropy" && screen.name !== "auto-entropy") {
+      let trackId = null;
+      if (screen.name === "queue" || screen.name === "contribute") {
+        trackId = screen.trackId;
+      } else if (screen.name === "auto-running") {
+        if (screen.subPhase.kind === "waiting" || screen.subPhase.kind === "contributing" || screen.subPhase.kind === "releasing") {
+          trackId = screen.subPhase.trackId;
+        }
+      }
+      if (trackId && session) {
         clearQueueCleanup();
-        api.leaveQueue(activeCeremonyId, screen.trackId, session.session_token).catch(() => {
+        clearSessionCleanup();
+        api.leaveQueue(activeCeremonyId, trackId, session.session_token).catch(() => {
+        });
+        clearSession().catch(() => {
         });
         setTimeout(() => exit(), 500);
+      } else if (session) {
+        clearSessionCleanup();
+        clearSession().catch(() => {
+        });
+        setTimeout(() => exit(), 100);
       } else {
         exit();
       }
       return;
     }
     if (key.backspace || key.delete) {
-      if (!initialCeremonyId && (screen.name === "tracks" || screen.name === "error")) {
+      if (!initialCeremonyId && (screen.name === "tracks" || screen.name === "error" || screen.name === "mode-select" || screen.name === "auto-summary")) {
         goCeremonyPicker();
         return;
       }
-      if (screen.name !== "tracks" && screen.name !== "loading" && screen.name !== "joining" && screen.name !== "entropy" && screen.name !== "ceremony-picker") {
+      if (screen.name === "auto-running" && (screen.subPhase.kind === "waiting" || screen.subPhase.kind === "contributing") && screen.current && session) {
+        const skipped = screen.current;
+        const skippedTrackId = screen.subPhase.trackId;
+        const skippedCircuitName = screen.subPhase.circuitName;
+        const sessionToken = session.session_token;
+        setScreen({
+          ...screen,
+          subPhase: {
+            kind: "releasing",
+            trackId: skippedTrackId,
+            circuitName: skippedCircuitName
+          }
+        });
+        api.leaveQueue(activeCeremonyId, skippedTrackId, sessionToken).catch((err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          process.stderr.write(
+            `[ceremony-tui] leaveQueue(${skippedTrackId}) failed during skip: ${msg}
+`
+          );
+        }).finally(() => {
+          setScreen((prev) => {
+            if (prev.name !== "auto-running" || prev.subPhase.kind !== "releasing" || prev.subPhase.trackId !== skippedTrackId) {
+              return prev;
+            }
+            return {
+              ...prev,
+              current: null,
+              subPhase: { kind: "queueing" },
+              done: [
+                ...prev.done,
+                {
+                  trackId: skipped.id,
+                  circuitName: skipped.circuit_name,
+                  result: "failed",
+                  reason: "user skipped"
+                }
+              ]
+              // Don't queue skipped circuits for retry — the user
+              // actively chose to skip, so a silent retry would
+              // defeat that intent.
+            };
+          });
+        });
+        return;
+      }
+      if (screen.name !== "tracks" && screen.name !== "loading" && screen.name !== "joining" && screen.name !== "entropy" && screen.name !== "auto-entropy" && screen.name !== "ceremony-picker") {
         goHome();
       }
       return;
@@ -1042,10 +1795,27 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
       }
       return;
     }
+    if (screen.name === "mode-select") {
+      if (q === "k") {
+        setEntropyMode((m) => m === "mouse" ? "keyboard" : "mouse");
+        return;
+      }
+      if (key.return) {
+        setScreen({ name: "auto-entropy", tracks: screen.tracks });
+        return;
+      }
+      if (q === "n" || q === "m") {
+        setSelectedIdx(0);
+        setScreen({ name: "tracks", tracks: screen.tracks });
+        return;
+      }
+      return;
+    }
     if (screen.name === "tracks") {
       const { tracks } = screen;
       if (key.tab) {
         setTab((t) => (t + 1) % 2);
+        setContribCursor(0);
         return;
       }
       if (tab === 0) {
@@ -1059,7 +1829,33 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
         }
         if (key.return) {
           const t = tracks[selectedIdx];
-          if (t && t.status === "open" && !contributed[t.id]) joinTrack(t);
+          if (t && t.status === "open") joinTrack(t);
+          return;
+        }
+      } else if (tab === 1) {
+        const myContribs = Object.values(contributed).flat().filter((c) => c.ceremonyId === activeCeremonyId).sort((a, b) => {
+          const ta = a.verifiedAt ? Date.parse(a.verifiedAt) : 0;
+          const tb = b.verifiedAt ? Date.parse(b.verifiedAt) : 0;
+          return tb - ta;
+        });
+        if (key.upArrow) {
+          setContribCursor((i) => Math.max(0, i - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setContribCursor((i) => Math.min(myContribs.length - 1, i + 1));
+          return;
+        }
+        if (q === "c") {
+          const target = myContribs[contribCursor];
+          if (target && target.contributionHash) {
+            copyToClipboardOSC52(target.contributionHash);
+            setCopyToast(`\u2713 Hash copied (round #${target.sequenceNumber})`);
+            setTimeout(() => setCopyToast(null), 2e3);
+          } else if (target) {
+            setCopyToast("Nothing to copy \u2014 hash is still pending");
+            setTimeout(() => setCopyToast(null), 2e3);
+          }
           return;
         }
       }
@@ -1073,52 +1869,55 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
     }
   });
   if (showInfo) {
-    return /* @__PURE__ */ jsx7(InfoModal, {});
+    return /* @__PURE__ */ jsx8(InfoModal, {});
   }
   if (screen.name === "name-input") {
     const { value } = screen;
     const canSubmit = value.trim().length > 0;
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony: null }),
-      /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginTop: 1, gap: 1, children: [
-        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Who are you contributing as?" }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Your display name appears next to your contributions in the public transcript. Pick anything \u2014 your real name, a handle, or hit Tab for a random anonymous name." }),
-        /* @__PURE__ */ jsxs7(Box7, { children: [
-          /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: "  > " }),
-          /* @__PURE__ */ jsx7(Text7, { children: value }),
-          /* @__PURE__ */ jsx7(Text7, { color: "cyan", inverse: true, children: " " })
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony: null }),
+      /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginTop: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Who are you contributing as?" }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Your display name appears next to your contributions in the public transcript. Pick anything \u2014 your real name, a handle, or hit Tab for a random anonymous name." }),
+        /* @__PURE__ */ jsxs8(Box8, { children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: "  > " }),
+          /* @__PURE__ */ jsx8(Text8, { children: value }),
+          /* @__PURE__ */ jsx8(Text8, { color: "cyan", inverse: true, children: " " })
         ] }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: canSubmit ? "Enter to continue  \xB7  Tab rerolls random name  \xB7  \u232B backspace  \xB7  Esc to quit" : "Type a name, or press Tab to suggest a random anonymous one  \xB7  Esc to quit" })
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: canSubmit ? "Enter to continue  \xB7  Tab rerolls random name  \xB7  \u232B backspace  \xB7  Esc to quit" : "Type a name, or press Tab to suggest a random anonymous one  \xB7  Esc to quit" })
       ] })
     ] });
   }
   if (screen.name === "ceremony-picker") {
     const { ceremonies, loading } = screen;
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony: null }),
-      loading ? /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Loading ceremonies..." }) : ceremonies.length === 0 ? /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", gap: 1, children: [
-        /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: "No ceremonies found." }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "The server may not have any active ceremonies yet." }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Q to quit" })
-      ] }) : /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Select a ceremony:" }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " + "\u2500".repeat(60) }),
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony: null }),
+      loading ? /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Loading ceremonies..." }),
+        /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q / Ctrl+C / Ctrl+Z to quit" }) })
+      ] }) : ceremonies.length === 0 ? /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", gap: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "No ceremonies found." }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "The server may not have any active ceremonies yet." }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q to quit" })
+      ] }) : /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Select a ceremony:" }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "  " + "\u2500".repeat(60) }),
         ceremonies.map((c, i) => {
           const isSelected = i === selectedIdx;
           const isOpen = c.status === "open";
           const statusColor = c.status === "open" ? "green" : c.status === "completed" ? "cyan" : "yellow";
           const statusLabel = ceremonyStatusLabel(c.status);
-          return /* @__PURE__ */ jsxs7(Box7, { gap: 2, children: [
-            /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "cyan" : isOpen ? void 0 : "gray", children: [
+          return /* @__PURE__ */ jsxs8(Box8, { gap: 2, children: [
+            /* @__PURE__ */ jsxs8(Text8, { color: isSelected ? "cyan" : isOpen ? void 0 : "gray", children: [
               isSelected ? "\u25B6 " : "  ",
               c.name.padEnd(30)
             ] }),
-            /* @__PURE__ */ jsxs7(Text7, { color: statusColor, children: [
+            /* @__PURE__ */ jsxs8(Text8, { color: statusColor, children: [
               "[",
               statusLabel,
               "]"
             ] }),
-            /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+            /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
               c.track_count,
               " track",
               c.track_count !== 1 ? "s" : "",
@@ -1129,164 +1928,496 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
             ] })
           ] }, c.id);
         }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " + "\u2500".repeat(60) }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "  " + "\u2500".repeat(60) }),
         (() => {
           const c = ceremonies[selectedIdx];
           if (!c) return null;
+          const navHint = /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2191/\u2193 select \xB7 Enter join \xB7 Q / Ctrl+C / Ctrl+Z to quit" });
           if (c.status === "initialized") {
-            return /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
-              "  ",
-              "This ceremony is not yet open for contributions. The Umbra team is still preparing the circuits \u2014 please check back shortly."
+            return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+                "  ",
+                "This ceremony is not yet open for contributions. The Umbra team is still preparing the circuits \u2014 please check back shortly."
+              ] }),
+              navHint
             ] });
           }
           if (c.status === "finalizing") {
-            return /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
-              "  ",
-              "Contributions are closed. The ceremony is computing the final verification key \u2014 no further contributions can be added."
+            return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+                "  ",
+                "Contributions are closed. The ceremony is computing the final verification key \u2014 no further contributions can be added."
+              ] }),
+              navHint
             ] });
           }
           if (c.status === "completed") {
-            return /* @__PURE__ */ jsxs7(Text7, { color: "cyan", children: [
-              "  ",
-              "Ceremony complete. The verification keys are finalised \u2014 thank you to everyone who contributed."
+            return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs8(Text8, { color: "cyan", children: [
+                "  ",
+                "Ceremony complete. The verification keys are finalised \u2014 thank you to everyone who contributed."
+              ] }),
+              navHint
             ] });
           }
-          return /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2191/\u2193 select \xB7 Enter join \xB7 Q quit" });
+          return navHint;
         })()
       ] })
     ] });
   }
   if (screen.name === "loading") {
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony }),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Loading tracks..." })
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Loading tracks..." }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q / Ctrl+C / Ctrl+Z to quit" }) })
+    ] });
+  }
+  if (screen.name === "mode-select") {
+    const { tracks } = screen;
+    const openCount = tracks.filter((t) => t.status === "open").length;
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony }),
+      /* @__PURE__ */ jsxs8(
+        Box8,
+        {
+          flexDirection: "column",
+          borderStyle: "round",
+          borderColor: "cyan",
+          paddingX: 2,
+          paddingY: 0,
+          children: [
+            /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: "Automate?" }),
+            /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+              openCount,
+              " circuit",
+              openCount === 1 ? "" : "s",
+              " open \xB7 auto runs the whole loop"
+            ] }),
+            /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs8(Text8, { children: [
+                /* @__PURE__ */ jsx8(Text8, { bold: true, color: "green", children: "Enter" }),
+                "  ",
+                "auto \xB7 entropy once, every circuit in order"
+              ] }),
+              /* @__PURE__ */ jsxs8(Text8, { children: [
+                /* @__PURE__ */ jsx8(Text8, { bold: true, color: "yellow", children: "N" }),
+                "      ",
+                "manual \xB7 pick circuits one at a time"
+              ] }),
+              /* @__PURE__ */ jsxs8(Text8, { children: [
+                /* @__PURE__ */ jsx8(Text8, { bold: true, color: "magenta", children: "K" }),
+                "      ",
+                "input:",
+                " ",
+                /* @__PURE__ */ jsx8(Text8, { bold: true, color: entropyMode === "mouse" ? "cyan" : "yellow", children: entropyMode }),
+                " ",
+                /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "(press K to toggle)" })
+              ] })
+            ] })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u232B back \xB7 Q quit" }) })
+    ] });
+  }
+  if (screen.name === "auto-entropy") {
+    const { tracks } = screen;
+    const onComplete = (masterSeed) => {
+      const ordered = orderTracksForAuto(tracks, contributed);
+      setScreen({
+        name: "auto-running",
+        tracks,
+        masterSeed,
+        remaining: ordered,
+        retryQueue: [],
+        retryingPhase: false,
+        done: [],
+        current: null,
+        subPhase: { kind: "queueing" }
+      });
+    };
+    const onError = (e) => setScreen({ name: "error", message: e.message, recoverable: false });
+    if (entropyMode === "mouse") {
+      return /* @__PURE__ */ jsx8(
+        MouseEntropyCollector,
+        {
+          title: `Auto-mode entropy \xB7 one drawing seeds every circuit (HKDF per circuit)`,
+          onComplete,
+          onError
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony, subtitle: "Auto-mode entropy \xB7 seeds every circuit (HKDF)" }),
+      /* @__PURE__ */ jsx8(EntropyCollector, { onComplete, onError })
+    ] });
+  }
+  if (screen.name === "auto-running") {
+    const totalCount = screen.done.length + screen.remaining.length + screen.retryQueue.length + (screen.current ? 1 : 0);
+    const verifiedCount = screen.done.filter((d) => d.result === "verified").length;
+    const failedCount = screen.done.filter((d) => d.result === "failed").length;
+    const currentLabel = screen.current ? `current: ${screen.current.circuit_name}` : "advancing to next circuit\u2026";
+    const progressStrip = /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(60) }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: "cyan", children: "Auto-mode" }),
+        "  \xB7  ",
+        /* @__PURE__ */ jsx8(Text8, { children: verifiedCount }),
+        "/",
+        /* @__PURE__ */ jsx8(Text8, { children: totalCount }),
+        " verified",
+        failedCount > 0 && /* @__PURE__ */ jsxs8(Fragment3, { children: [
+          "  \xB7  ",
+          /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+            failedCount,
+            " failed"
+          ] }),
+          screen.retryingPhase ? " (retrying)" : ""
+        ] }),
+        screen.retryQueue.length > 0 && !screen.retryingPhase && /* @__PURE__ */ jsxs8(Fragment3, { children: [
+          "  \xB7  ",
+          /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+            screen.retryQueue.length,
+            " queued for retry"
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: currentLabel }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(60) })
+    ] });
+    if (screen.subPhase.kind === "releasing") {
+      const sub = screen.subPhase;
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(
+          Header,
+          {
+            ceremony,
+            subtitle: `Auto-mode \xB7 releasing slot for ${sub.circuitName}`
+          }
+        ),
+        progressStrip,
+        /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+          "\u23F3 Releasing slot for ",
+          sub.circuitName,
+          "\u2026"
+        ] }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Waiting for the server to confirm the slot is free before joining the next circuit's queue." }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q / Ctrl+C / Ctrl+Z abort run" })
+      ] });
+    }
+    if (screen.subPhase.kind === "queueing") {
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(Header, { ceremony, subtitle: "Auto-mode \xB7 joining next queue" }),
+        progressStrip,
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Picking the next circuit\u2026" }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q / Ctrl+C / Ctrl+Z to abort (releases any active slot)" })
+      ] });
+    }
+    if (screen.subPhase.kind === "waiting") {
+      const sub = screen.subPhase;
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(
+          Header,
+          {
+            ceremony,
+            subtitle: `Auto-mode \xB7 waiting for slot \xB7 ${sub.circuitName}`
+          }
+        ),
+        progressStrip,
+        /* @__PURE__ */ jsx8(
+          QueueView,
+          {
+            ceremonyId: activeCeremonyId,
+            trackId: sub.trackId,
+            token: session.session_token,
+            onReady: (status) => {
+              const entropy = deriveCircuitEntropy(
+                screen.masterSeed,
+                activeCeremonyId,
+                sub.circuitName
+              );
+              setScreen({
+                ...screen,
+                subPhase: {
+                  kind: "contributing",
+                  trackId: sub.trackId,
+                  circuitName: sub.circuitName,
+                  slotStatus: status,
+                  entropy
+                }
+              });
+            },
+            onError: (e) => {
+              const failedTrack = screen.current;
+              const newDone = {
+                trackId: failedTrack.id,
+                circuitName: failedTrack.circuit_name,
+                result: "failed",
+                reason: e.message
+              };
+              setScreen({
+                ...screen,
+                current: null,
+                subPhase: { kind: "queueing" },
+                done: [...screen.done, newDone],
+                retryQueue: screen.retryingPhase ? screen.retryQueue : [...screen.retryQueue, failedTrack]
+              });
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u232B Backspace skip this circuit  \xB7  Q / Ctrl+C / Ctrl+Z abort run" })
+      ] });
+    }
+    if (screen.subPhase.kind === "contributing") {
+      const sub = screen.subPhase;
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx8(
+          Header,
+          {
+            ceremony,
+            subtitle: `Auto-mode \xB7 contributing \xB7 ${sub.circuitName}`
+          }
+        ),
+        progressStrip,
+        /* @__PURE__ */ jsx8(
+          ContributeFlow,
+          {
+            ceremonyId: activeCeremonyId,
+            trackId: sub.trackId,
+            token: session.session_token,
+            slotStatus: sub.slotStatus,
+            entropy: sub.entropy,
+            displayName: displayName2,
+            onComplete: async (contributionId, receipt) => {
+              const local = {
+                contributionId,
+                sequenceNumber: receipt?.sequence_number ?? 0,
+                contributionHash: receipt?.contribution_hash ?? "",
+                circuitName: sub.circuitName,
+                ceremonyId: activeCeremonyId,
+                verifiedAt: receipt?.verified_at ?? (/* @__PURE__ */ new Date()).toISOString()
+              };
+              await recordContribution(sub.trackId, local);
+              setContributed((prev) => {
+                const existing = prev[sub.trackId] ?? [];
+                if (existing.some((c) => c.contributionId === local.contributionId)) return prev;
+                return { ...prev, [sub.trackId]: [...existing, local] };
+              });
+              const successTrack = screen.current;
+              setScreen({
+                ...screen,
+                current: null,
+                subPhase: { kind: "queueing" },
+                done: [
+                  ...screen.done,
+                  {
+                    trackId: successTrack.id,
+                    circuitName: successTrack.circuit_name,
+                    result: "verified",
+                    hash: local.contributionHash
+                  }
+                ]
+              });
+            },
+            onError: (e) => {
+              const failedTrack = screen.current;
+              setScreen({
+                ...screen,
+                current: null,
+                subPhase: { kind: "queueing" },
+                done: [
+                  ...screen.done,
+                  {
+                    trackId: failedTrack.id,
+                    circuitName: failedTrack.circuit_name,
+                    result: "failed",
+                    reason: e.message
+                  }
+                ],
+                retryQueue: screen.retryingPhase ? screen.retryQueue : [...screen.retryQueue, failedTrack]
+              });
+            }
+          }
+        )
+      ] });
+    }
+    return null;
+  }
+  if (screen.name === "auto-summary") {
+    const verified = screen.outcomes.filter((o) => o.result === "verified");
+    const failed = screen.outcomes.filter((o) => o.result === "failed");
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony, subtitle: "Auto-mode \xB7 complete" }),
+      /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", gap: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { bold: true, color: failed.length === 0 ? "green" : "yellow", children: failed.length === 0 ? `\u2713 Auto-mode complete \u2014 ${verified.length} circuits verified` : `\u26A0 Auto-mode complete with ${failed.length} failure${failed.length === 1 ? "" : "s"}` }),
+        verified.length > 0 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Verified contributions:" }),
+          verified.map((o, i) => /* @__PURE__ */ jsxs8(Box8, { paddingLeft: 2, children: [
+            /* @__PURE__ */ jsx8(Text8, { color: "green", children: "\u2713 " }),
+            /* @__PURE__ */ jsx8(Text8, { children: elideMiddle(o.circuitName, 42).padEnd(44) }),
+            /* @__PURE__ */ jsx8(Text8, { color: "cyan", children: o.hash ? o.hash.slice(0, 16) + "\u2026" : "" })
+          ] }, i))
+        ] }),
+        failed.length > 0 && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "Failed (retry already attempted):" }),
+          failed.map((o, i) => /* @__PURE__ */ jsxs8(Box8, { paddingLeft: 2, flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs8(Box8, { children: [
+              /* @__PURE__ */ jsx8(Text8, { color: "red", children: "\u2717 " }),
+              /* @__PURE__ */ jsx8(Text8, { children: elideMiddle(o.circuitName, 42) })
+            ] }),
+            /* @__PURE__ */ jsx8(Box8, { paddingLeft: 4, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: o.reason ?? "(no reason recorded)" }) })
+          ] }, i)),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u232B Backspace / B \u2014 back to track list (you can retry failed circuits manually)" })
+        ] }),
+        /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q / Ctrl+C / Ctrl+Z \u2014 quit" })
+      ] })
     ] });
   }
   if (screen.name === "error") {
     const backHint = !initialCeremonyId ? "\u232B Backspace \u2014 back to ceremony list  \xB7  Q to quit" : screen.recoverable ? "\u232B Backspace / B to go back  \xB7  Q to quit" : "Q to quit";
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony }),
-      /* @__PURE__ */ jsxs7(Text7, { color: "red", bold: true, children: [
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony }),
+      /* @__PURE__ */ jsxs8(Text8, { color: "red", bold: true, children: [
         "\u2717 ",
         screen.message
       ] }),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: backHint })
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: backHint })
     ] });
   }
   if (screen.name === "tracks") {
     const { tracks } = screen;
     const openTracks = tracks.filter((t) => t.status === "open");
-    const myContributions = Object.values(contributed).filter(
-      (c) => c.ceremonyId === activeCeremonyId
-    );
-    const TabBar = () => /* @__PURE__ */ jsxs7(Box7, { gap: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ jsx7(Text7, { bold: tab === 0, color: tab === 0 ? "cyan" : void 0, dimColor: tab !== 0, children: tab === 0 ? "[ Dashboard ]" : "  Dashboard  " }),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "|" }),
-      /* @__PURE__ */ jsx7(Text7, { bold: tab === 1, color: tab === 1 ? "cyan" : void 0, dimColor: tab !== 1, children: tab === 1 ? `[ My Contributions (${myContributions.length}) ]` : `  My Contributions (${myContributions.length})  ` }),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " Tab to switch" })
+    const myContributions = Object.values(contributed).flat().filter((c) => c.ceremonyId === activeCeremonyId).sort((a, b) => {
+      const ta = a.verifiedAt ? Date.parse(a.verifiedAt) : 0;
+      const tb = b.verifiedAt ? Date.parse(b.verifiedAt) : 0;
+      return tb - ta;
+    });
+    const TabBar = () => /* @__PURE__ */ jsxs8(Box8, { gap: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: tab === 0, color: tab === 0 ? "cyan" : void 0, dimColor: tab !== 0, children: tab === 0 ? "[ Dashboard ]" : "  Dashboard  " }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "|" }),
+      /* @__PURE__ */ jsx8(Text8, { bold: tab === 1, color: tab === 1 ? "cyan" : void 0, dimColor: tab !== 1, children: tab === 1 ? `[ My Contributions (${myContributions.length}) ]` : `  My Contributions (${myContributions.length})  ` }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " Tab to switch" })
     ] });
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony }),
-      /* @__PURE__ */ jsx7(TabBar, {}),
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony }),
+      /* @__PURE__ */ jsx8(TabBar, {}),
       tab === 0 ? (
         // ── Dashboard tab ────────────────────────────────────────────────
-        /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-            "  CIRCUIT".padEnd(30),
-            "TOTAL".padEnd(10),
+        // CIRCUIT column is sized to fit the longest mainnet name
+        // (`claim-deposit-into-confidential-amount-n4` = 41 chars). Names
+        // longer than that are middle-elided so the disambiguating suffix
+        // (-n1/-n2/-n4) stays visible — previously a hard slice(0,24)
+        // showed every claim variant as `claim-deposit-into-confi..`.
+        /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+            "  CIRCUIT".padEnd(46),
+            "TOTAL".padEnd(8),
             "QUEUE".padEnd(8),
-            "STATUS".padEnd(16),
+            "STATUS".padEnd(14),
             "MY CONTRIBUTIONS"
           ] }),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " + "\u2500".repeat(70) }),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "  " + "\u2500".repeat(90) }),
           tracks.map((t, i) => {
             const isSelected = i === selectedIdx;
             const canContribute = t.status === "open";
-            const nameClipped = t.circuit_name.length > 26 ? t.circuit_name.slice(0, 24) + ".." : t.circuit_name;
+            const nameDisplay = elideMiddle(t.circuit_name, 42);
             const statusColor = t.status === "open" ? "green" : t.status === "finalized" ? "cyan" : "yellow";
-            const myContrib = contributed[t.id];
-            return /* @__PURE__ */ jsxs7(Box7, { children: [
-              /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "cyan" : canContribute ? void 0 : "gray", children: [
+            const myRounds = roundCount(contributed, t.id);
+            return /* @__PURE__ */ jsxs8(Box8, { children: [
+              /* @__PURE__ */ jsxs8(Text8, { color: isSelected ? "cyan" : canContribute ? void 0 : "gray", children: [
                 isSelected ? "\u25B6 " : "  ",
-                nameClipped.padEnd(28),
-                String(t.contribution_count).padEnd(10),
+                nameDisplay.padEnd(44),
+                String(t.contribution_count).padEnd(8),
                 String(t.queue_depth).padEnd(8)
               ] }),
-              /* @__PURE__ */ jsx7(Text7, { color: statusColor, children: trackStatusLabel(t.status).padEnd(16) }),
-              myContrib ? isSelected ? /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
-                "\u2713 contributed (round #",
-                myContrib.sequenceNumber,
-                ") \u2014 already done"
-              ] }) : /* @__PURE__ */ jsxs7(Text7, { color: "green", children: [
-                "\u2713 contributed (round #",
-                myContrib.sequenceNumber,
+              /* @__PURE__ */ jsx8(Text8, { color: statusColor, children: trackStatusLabel(t.status).padEnd(14) }),
+              myRounds > 0 ? canContribute && isSelected ? /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
+                "\u2713 contributed (",
+                myRounds,
+                " round",
+                myRounds === 1 ? "" : "s",
+                ") \u2014",
+                " ",
+                /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "Enter to add more" })
+              ] }) : /* @__PURE__ */ jsxs8(Text8, { color: "green", children: [
+                "\u2713 contributed (",
+                myRounds,
+                " round",
+                myRounds === 1 ? "" : "s",
                 ")"
-              ] }) : canContribute ? isSelected ? /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: "\u2190 Enter to contribute" }) : /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "not contributed" }) : /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2014" })
+              ] }) : canContribute ? isSelected ? /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "\u2190 Enter to contribute" }) : /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "not contributed" }) : /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2014" })
             ] }, t.id);
           }),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " + "\u2500".repeat(70) }),
-          openTracks.length === 0 ? /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: "No circuits are open for contributions right now \u2014 the ceremony may be closing or already complete." }) : /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "  " + "\u2500".repeat(70) }),
+          openTracks.length === 0 ? /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "No circuits are open for contributions right now \u2014 the ceremony may be closing or already complete." }) : /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
             "\u2191/\u2193 select \xB7 Enter contribute \xB7 R refresh \xB7 Q quit",
             !initialCeremonyId ? "  \xB7  \u232B back to ceremony list" : ""
           ] })
         ] })
       ) : (
         // ── My Contributions tab ─────────────────────────────────────────
-        /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: myContributions.length === 0 ? /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", gap: 1, children: [
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No contributions yet." }),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Switch to Dashboard tab and press Enter on a circuit to contribute." })
-        ] }) : /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-            "  CIRCUIT".padEnd(28),
-            "ROUND".padEnd(8),
-            "HASH".padEnd(20),
-            "TIME"
+        /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: myContributions.length === 0 ? /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", gap: 1, children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "No contributions yet." }),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Switch to Dashboard tab and press Enter on a circuit to contribute." })
+        ] }) : /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+            "  CIRCUIT".padEnd(44),
+            "ROUND".padEnd(7),
+            "VERIFIED AT".padEnd(22)
           ] }),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " + "\u2500".repeat(68) }),
-          myContributions.map((c, i) => /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsxs7(Box7, { children: [
-              /* @__PURE__ */ jsx7(Text7, { color: "green", children: " \u2713 " }),
-              /* @__PURE__ */ jsx7(Text7, { bold: true, children: c.circuitName.padEnd(24) }),
-              /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: "#" + c.sequenceNumber + " " }),
-              /* @__PURE__ */ jsx7(Text7, { color: "cyan", children: c.contributionHash ? c.contributionHash.slice(0, 16) + "..." : "(pending)" })
-            ] }),
-            /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
-              "     ",
-              c.verifiedAt ? new Date(c.verifiedAt).toLocaleString() : ""
-            ] })
-          ] }, i)),
-          /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "  " + "\u2500".repeat(68) }),
-          /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "  " + "\u2500".repeat(90) }),
+          myContributions.map((c, i) => {
+            const isSel = i === contribCursor;
+            return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs8(Box8, { children: [
+                /* @__PURE__ */ jsx8(Text8, { color: isSel ? "cyan" : "green", children: isSel ? "\u25B6 " : "  " }),
+                /* @__PURE__ */ jsx8(Text8, { bold: isSel, children: elideMiddle(c.circuitName, 40).padEnd(42) }),
+                /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: ("#" + c.sequenceNumber).padEnd(7) }),
+                /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: c.verifiedAt ? new Date(c.verifiedAt).toLocaleString() : "\u2014" })
+              ] }),
+              /* @__PURE__ */ jsx8(Box8, { paddingLeft: 4, children: /* @__PURE__ */ jsxs8(Text8, { color: isSel ? "cyan" : "gray", dimColor: !isSel, children: [
+                "hash:",
+                " ",
+                c.contributionHash ? c.contributionHash : "(pending \u2014 verify still in flight)"
+              ] }) })
+            ] }, i);
+          }),
+          /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "  " + "\u2500".repeat(90) }),
+          copyToast ? /* @__PURE__ */ jsx8(Text8, { color: "green", children: copyToast }) : /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
             "Total: ",
             myContributions.length,
             " contribution",
             myContributions.length !== 1 ? "s" : "",
             "  \xB7  ",
-            "Tab to switch \xB7 Q to quit"
+            "\u2191/\u2193 select \xB7 C copy hash \xB7 Tab switch \xB7 Q quit"
           ] })
         ] }) })
       )
     ] });
   }
   if (screen.name === "joining") {
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony }),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Joining queue..." })
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Joining queue..." }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Q / Ctrl+C / Ctrl+Z to quit" }) })
     ] });
   }
   if (screen.name === "queue") {
     const { trackId, circuitName } = screen;
-    const priorContrib = contributed[trackId];
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony, subtitle: `Circuit: ${circuitName}` }),
-      priorContrib && /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, paddingX: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: "yellow", children: [
-        "\u26A0 You already contributed to this circuit (round #",
-        priorContrib.sequenceNumber,
-        ").",
-        " ",
-        "Contributing again is allowed and adds more entropy."
+    const priorRounds = roundCount(contributed, trackId);
+    const lastContrib = latestContribution(contributed, trackId);
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony, subtitle: `Circuit: ${circuitName}` }),
+      priorRounds > 0 && lastContrib && /* @__PURE__ */ jsx8(Box8, { marginBottom: 1, paddingX: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+        "\u26A0 You've contributed to this circuit ",
+        priorRounds,
+        " time",
+        priorRounds === 1 ? "" : "s",
+        " (latest: round #",
+        lastContrib.sequenceNumber,
+        "). Each additional round adds more entropy and strengthens the ceremony \u2014 go ahead."
       ] }) }),
-      /* @__PURE__ */ jsx7(
+      /* @__PURE__ */ jsx8(
         QueueView,
         {
           ceremonyId: activeCeremonyId,
@@ -1296,27 +2427,39 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
           onError: (e) => setScreen({ name: "error", message: e.message, recoverable: true })
         }
       ),
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u232B Backspace to go back \xB7 Q to quit" })
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u232B Backspace to go back \xB7 Q to quit" })
     ] });
   }
   if (screen.name === "entropy") {
     const { trackId, circuitName, slotStatus } = screen;
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony, subtitle: `Circuit: ${circuitName}  \xB7  Your turn!` }),
-      /* @__PURE__ */ jsx7(
-        EntropyCollector,
+    const onComplete = (entropy) => setScreen({ name: "contribute", trackId, circuitName, slotStatus, entropy });
+    const onError = (e) => setScreen({ name: "error", message: e.message, recoverable: false });
+    if (entropyMode === "mouse") {
+      return /* @__PURE__ */ jsx8(
+        MouseEntropyCollector,
         {
-          onComplete: (entropy) => setScreen({ name: "contribute", trackId, circuitName, slotStatus, entropy }),
-          onError: (e) => setScreen({ name: "error", message: e.message, recoverable: false })
+          title: `Your turn \xB7 ${circuitName} \u2014 draw entropy for this contribution`,
+          onComplete,
+          onError
         }
-      )
+      );
+    }
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(
+        Header,
+        {
+          ceremony,
+          subtitle: `Circuit: ${circuitName}  \xB7  Type to collect entropy`
+        }
+      ),
+      /* @__PURE__ */ jsx8(EntropyCollector, { onComplete, onError })
     ] });
   }
   if (screen.name === "contribute") {
     const { trackId, circuitName, slotStatus, entropy } = screen;
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony, subtitle: `Circuit: ${circuitName}  \xB7  Contributing` }),
-      /* @__PURE__ */ jsx7(
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony, subtitle: `Circuit: ${circuitName}  \xB7  Contributing` }),
+      /* @__PURE__ */ jsx8(
         ContributeFlow,
         {
           ceremonyId: activeCeremonyId,
@@ -1335,7 +2478,13 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
               verifiedAt: receipt?.verified_at ?? (/* @__PURE__ */ new Date()).toISOString()
             };
             await recordContribution(trackId, local);
-            setContributed((prev) => ({ ...prev, [trackId]: local }));
+            setContributed((prev) => {
+              const existing = prev[trackId] ?? [];
+              if (existing.some((c) => c.contributionId === local.contributionId)) {
+                return prev;
+              }
+              return { ...prev, [trackId]: [...existing, local] };
+            });
             setScreen({ name: "done", contribution: local });
           },
           onError: (e) => setScreen({ name: "error", message: e.message, recoverable: false })
@@ -1345,41 +2494,47 @@ function App({ ceremonyId: initialCeremonyId, displayName: initialDisplayName })
   }
   if (screen.name === "done") {
     const { contribution } = screen;
-    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx7(Header, { ceremony }),
-      /* @__PURE__ */ jsx7(Attestation, { contribution }),
-      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u232B Backspace / B = contribute to another circuit \xB7 Q to quit" }) })
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Header, { ceremony }),
+      /* @__PURE__ */ jsx8(Attestation, { contribution }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u232B Backspace / B = contribute to another circuit \xB7 Q to quit" }) })
     ] });
   }
   return null;
 }
 
 // src/index.tsx
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx9 } from "react/jsx-runtime";
 var ceremonyId = process.env["CEREMONY_ID"] ?? "";
 var displayName = process.env["CONTRIBUTOR_NAME"];
 process.stdout.write("\x1B[?1049h\x1B[H");
 function restoreScreen() {
   process.stdout.write("\x1B[?1049l");
 }
-async function gracefulExit(code = 0) {
+var exiting = false;
+async function gracefulExit(code = 0, deliberate = false) {
+  if (exiting) {
+    process.exit(code);
+  }
+  exiting = true;
   restoreScreen();
   await runQueueCleanup();
+  if (deliberate) {
+    await runSessionCleanup();
+  }
   process.exit(code);
 }
-process.on("SIGINT", () => {
-  gracefulExit(0).catch(() => {
-    restoreScreen();
-    process.exit(0);
-  });
-});
-process.on("SIGTERM", () => {
-  gracefulExit(0).catch(() => {
-    restoreScreen();
-    process.exit(0);
+globalThis.__ceremonyGracefulExit = gracefulExit;
+var DELIBERATE_SIGNALS = /* @__PURE__ */ new Set(["SIGINT", "SIGTSTP"]);
+for (const signal of ["SIGINT", "SIGTERM", "SIGTSTP", "SIGHUP"]) {
+  process.on(signal, () => {
+    gracefulExit(0, DELIBERATE_SIGNALS.has(signal)).catch(() => {
+      restoreScreen();
+      process.exit(0);
+    });
   });
-});
-var { waitUntilExit } = render(/* @__PURE__ */ jsx8(App, { ceremonyId, displayName }), {
+}
+var { waitUntilExit } = render(/* @__PURE__ */ jsx9(App, { ceremonyId, displayName }), {
   exitOnCtrlC: false
 });
 await waitUntilExit();