ui-ota: the publisher (tools/ui-ota/publish.mjs), publish-manifest.sh --ui and --no-ui, the plan with the security notes

publish.mjs packs the fifteen served files with one fixed mtime (reproducible; the self-test checks it), hashes, signs
the entry through igneum-ota-sign sign-ui with the key in ~/.config/igneum (never read or printed here), copies the
bundle into the folder's ui/ and hands ui.json to publish-manifest.sh --ui, the one writer of the signed manifest,
which verifies the entry and the bundle's hash before signing; --dry-run writes nothing, --verify reads the live
manifest back against dl/<token>/ui and dl/public/ui; --no-ui withdraws the channel. Both self-tests sit on the one
gate. docs/plans/ui-ota.md: the shape, the engine, the security notes, the operator recipe, the tests, per tier.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

.gitignore

@@ -32,6 +32,10 @@ vendor/igneum-node-ship/
 brand/trademark/pbip-pack/
 brand/trademark/*.zip
 
+# cargo target dirs of the shipper's local test runs and the build box's fetched artefacts (6 October 2026: a stray add -A staged 450 of them)
+app/igneum-app/target-tests/
+proving/igneum-prove/target-remote/
+**/target-remote/
 # the Discord bot and reddit bot dry-run renders
 tools/community/out/
 # the GPU workers built on igneum-build-1 (tools/workers-remote.sh); binaries, never committed

app/igneum-app/Cargo.lock

@@ -219,7 +219,7 @@ dependencies = [
 
 [[package]]
 name = "igneum-app"
-version = "0.3.14"
+version = "0.3.16"
 dependencies = [
  "ed25519-dalek",
  "getrandom",

app/igneum-app/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "igneum-app"
-version = "0.3.14"
+version = "0.3.16"
 edition = "2021"
 description = "Igneum Miner engine: supervises the node, the miner and the GPU workers, and serves the dashboard on 127.0.0.1"
 license = "MIT"

app/igneum-app/resources/igneum-app.rc

@@ -6,8 +6,8 @@
 1 ICON "igneum.ico"
 
 1 VERSIONINFO
-FILEVERSION     0,3,14,0
-PRODUCTVERSION  0,3,14,0
+FILEVERSION     0,3,16,0
+PRODUCTVERSION  0,3,16,0
 FILEFLAGSMASK   0x3fL
 FILEFLAGS       0x0L
 FILEOS          VOS_NT_WINDOWS32
@@ -20,12 +20,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName",      "Igneum"
             VALUE "FileDescription",  "Igneum Miner engine"
-            VALUE "FileVersion",      "0.3.14"
+            VALUE "FileVersion",      "0.3.16"
             VALUE "InternalName",     "igneum-app"
             VALUE "LegalCopyright",   "Igneum contributors"
             VALUE "OriginalFilename", "igneum-app.exe"
             VALUE "ProductName",      "Igneum Miner"
-            VALUE "ProductVersion",   "0.3.14"
+            VALUE "ProductVersion",   "0.3.16"
         END
     END
     BLOCK "VarFileInfo"

app/igneum-app/src/bin/ota-sign.rs

@@ -7,6 +7,9 @@
 //!   igneum-ota-sign embedded                                       prints the public key compiled into the app and its fingerprint
 //!   igneum-ota-sign fingerprint <public-key-file|hex>
 //!   igneum-ota-sign sha256 <file>                                  the file's sha256 and size, for the manifest
+//!   igneum-ota-sign sign-ui <private-key-file> <version> <sha256> <min-engine>    the interface entry's own signature
+//!                   (src/manifest.rs ui_sign_bytes; tools/ui-ota/publish.mjs calls this), same key
+//!   igneum-ota-sign verify-ui <public-key-file|hex|embedded> <version> <sha256> <min-engine> <signature-hex>
 //!   igneum-ota-sign sign-jobs <private-key-file> <igneum-jobs.json>    the remote-jobs file (src/jobs.rs), same key
 //!   igneum-ota-sign verify-jobs <public-key-file|hex> <igneum-jobs.json> <sig-file>
 //!   igneum-ota-sign envelope-jobs <public-key-file|hex> <igneum-jobs.json> <sig-file>   prints igneum-jobs.signed.json:
@@ -101,6 +104,26 @@ fn main() {
             let size = std::fs::metadata(p).map(|m| m.len()).unwrap_or(0);
             println!("{sum} {size}");
         }
+        Some("sign-ui") if args.len() == 5 => {
+            let seed = manifest::hex_decode(&read_key_arg(&args[1])).unwrap_or_else(|| die("private key is not hex"));
+            let seed: [u8; 32] = seed.try_into().unwrap_or_else(|_| die("private key is not 32 bytes"));
+            let sk = SigningKey::from_bytes(&seed);
+            if manifest::parse_version(&args[2]).is_none() || manifest::parse_version(&args[4]).is_none() {
+                die("the version and the engine floor are versions like 0.3.19 or 0.3.19.1");
+            }
+            if args[3].len() != 64 || !args[3].chars().all(|c| c.is_ascii_hexdigit()) {
+                die("the sha256 is 64 hex characters");
+            }
+            println!("{}", manifest::hex_encode(&sk.sign(&manifest::ui_sign_bytes(&args[2], &args[3], &args[4])).to_bytes()));
+        }
+        Some("verify-ui") if args.len() == 6 => {
+            let pk = if args[1] == "embedded" { manifest::OTA_PUBLIC_KEY_HEX.to_string() } else { read_key_arg(&args[1]) };
+            let e = manifest::UiEntry { version: args[2].clone(), sha256: args[3].to_ascii_lowercase(), size: 1, url: "https://x".into(), min_engine: args[4].clone(), signature: args[5].to_ascii_lowercase() };
+            match manifest::verify_ui_entry(&e, &pk) {
+                Ok(()) => println!("verifies"),
+                Err(e) => die(&e),
+            }
+        }
         Some("sign-jobs") if args.len() == 3 => {
             let seed = manifest::hex_decode(&read_key_arg(&args[1])).unwrap_or_else(|| die("private key is not hex"));
             let seed: [u8; 32] = seed.try_into().unwrap_or_else(|_| die("private key is not 32 bytes"));

app/igneum-app/src/card.rs

@@ -0,0 +1,80 @@
+//! The saved block card (miner-ui-5): the page draws the 1200x630 PNG on a canvas from the same words the card
+//! shows (no network call), posts it as a data URL to POST /api/card, and the engine writes it under
+//! `<data root>/cards/`. This module is the pure part: the base64 decode (no crate for it) and the file name.
+use std::path::{Path, PathBuf};
+
+/// `data:image/png;base64,....` -> the PNG bytes; None for anything that is not a base64 PNG data URL.
+pub fn decode_data_url(s: &str) -> Option<Vec<u8>> {
+    let rest = s.strip_prefix("data:image/png;base64,")?;
+    let bytes = decode_base64(rest)?;
+    if bytes.len() < 8 || bytes[..8] != [0x89, b'P', b'N', b'G', 0x0D, 0x0A, 0x1A, 0x0A] {
+        return None;
+    }
+    Some(bytes)
+}
+
+/// Standard base64 (RFC 4648, with or without `=` padding, whitespace ignored). None on a bad character.
+pub fn decode_base64(s: &str) -> Option<Vec<u8>> {
+    let mut out = Vec::with_capacity(s.len() * 3 / 4);
+    let mut acc: u32 = 0;
+    let mut bits = 0u32;
+    for c in s.bytes() {
+        let v = match c {
+            b'A'..=b'Z' => c - b'A',
+            b'a'..=b'z' => c - b'a' + 26,
+            b'0'..=b'9' => c - b'0' + 52,
+            b'+' | b'-' => 62,
+            b'/' | b'_' => 63,
+            b'=' | b'\n' | b'\r' | b' ' | b'\t' => continue,
+            _ => return None,
+        } as u32;
+        acc = (acc << 6) | v;
+        bits += 6;
+        if bits >= 8 {
+            bits -= 8;
+            out.push(((acc >> bits) & 0xFF) as u8);
+        }
+    }
+    Some(out)
+}
+
+/// `<root>/cards/igneum-block-<name>-<unix>.png`, the name reduced to [a-z0-9-] and at most 40 characters.
+pub fn card_path(root: &Path, name: &str, unix: u64) -> PathBuf {
+    let mut clean = String::new();
+    for c in name.to_ascii_lowercase().chars() {
+        if c.is_ascii_alphanumeric() { clean.push(c); } else if !clean.ends_with('-') { clean.push('-'); }
+    }
+    let clean: String = clean.trim_matches('-').chars().take(40).collect::<String>().trim_end_matches('-').to_string();
+    let clean = if clean.is_empty() { "block".to_string() } else { clean };
+    root.join("cards").join(format!("igneum-block-{clean}-{unix}.png"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn base64_decodes_with_and_without_padding() {
+        assert_eq!(decode_base64("aGVsbG8=").unwrap(), b"hello");
+        assert_eq!(decode_base64("aGVsbG8").unwrap(), b"hello");
+        assert_eq!(decode_base64("aGVs\nbG8gd29ybGQ=").unwrap(), b"hello world");
+        assert!(decode_base64("aGV$sbG8=").is_none());
+    }
+
+    #[test]
+    fn a_png_data_url_decodes_and_anything_else_is_refused() {
+        // the 8-byte PNG signature, base64
+        let sig = "iVBORw0KGgo=";
+        let png = decode_data_url(&format!("data:image/png;base64,{sig}")).unwrap();
+        assert_eq!(&png[..4], b"\x89PNG");
+        assert!(decode_data_url("data:image/jpeg;base64,/9j/").is_none());
+        assert!(decode_data_url("data:image/png;base64,aGVsbG8=").is_none(), "not a PNG");
+    }
+
+    #[test]
+    fn the_file_name_is_safe_and_dated() {
+        let p = card_path(Path::new("/data"), "Block 1,284,117 / RTX 4070", 1_791_362_116);
+        assert_eq!(p, PathBuf::from("/data/cards/igneum-block-block-1-284-117-rtx-4070-1791362116.png"));
+        assert_eq!(card_path(Path::new("/d"), "///", 1).file_name().unwrap(), "igneum-block-block-1.png");
+    }
+}

app/igneum-app/src/chainfacts.rs

@@ -0,0 +1,263 @@
+//! GET /api/ladder: the chain facts behind the miner's ladder (miner-ui-5, 7 October 2026). Every rung the dashboard
+//! shows is a number from the node's finality RPC, never a count this app keeps: `getFinalityWeights` (the per-key
+//! table: `keys[].blocks` in the weight window, `keys[].voter` against `params.dust`, `keys[].participation` over
+//! `params.presenceWindow`, `totalWeight`, `activeWeight`, `voters`, `checkpointIndex`) and `getFinalityCheckpoints`
+//! (`latestLockedIndex`, `nextIndex`, `finalityActive`). The network rate and the reward come from the public
+//! `/api/stats` (`hashrate`, `block_reward.miner_ign`, `block_reward.ramp_factor`), the observer's reading of the same
+//! node RPCs.
+//!
+//! Sources, in order: the local node's EVM port answering `igneum_getFinalityWeights` (OWED on the node: the finality
+//! RPCs are wRPC only today and the engine carries no websocket client), else the observer's `/api/live`, whose
+//! `finality.weights` is the node's `getFinalityWeights` relayed (field names in snake case, `keys[]` cut to 64, key ids
+//! as the first 8 hex of the key hash). The reply names its source so the dashboard can say it on hover. Cached 10 s.
+use serde_json::{json, Value};
+use std::process::Command;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+static CACHE: Mutex<Option<(Instant, Value)>> = Mutex::new(None);
+const TTL: Duration = Duration::from_secs(10);
+/// the observer relays at most this many keys (tools/observer/observer.mjs)
+pub const OBSERVER_KEYS_CAP: usize = 64;
+
+fn num(v: &Value) -> f64 {
+    match v {
+        Value::Number(n) => n.as_f64().unwrap_or(0.0),
+        Value::String(s) => s.parse().unwrap_or(0.0),
+        Value::Bool(b) => if *b { 1.0 } else { 0.0 },
+        _ => 0.0,
+    }
+}
+fn u(v: &Value) -> u64 { num(v).max(0.0) as u64 }
+fn get<'a>(v: &'a Value, keys: &[&str]) -> &'a Value {
+    for k in keys {
+        if let Some(x) = v.get(k) { return x; }
+    }
+    &Value::Null
+}
+
+/// One key's row in either spelling (the node's camelCase or the observer's snake case).
+fn key_row(k: &Value) -> Value {
+    let id_full = get(k, &["keyHash", "key_hash", "id"]).as_str().unwrap_or("").trim_start_matches("0x").to_ascii_lowercase();
+    let id: String = id_full.chars().take(8).collect();
+    let revealed = match k.get("revealed") { Some(r) => r.as_bool().unwrap_or(false), None => k.get("pubkey").and_then(|p| p.as_str()).map(|p| !p.is_empty()).unwrap_or(false) };
+    json!({
+        "id": id,
+        "blocks": u(get(k, &["blocks"])),
+        "voter": get(k, &["voter"]).as_bool().unwrap_or(false),
+        "participation": num(get(k, &["participation"])),
+        "stripped_until_daa": u(get(k, &["strippedUntilDaa", "stripped_until_daa"])),
+        "revealed": revealed,
+    })
+}
+
+/// Is `id` one of this machine's key ids? A prefix of the other of at least 6 hex counts (the engine keeps 8, a
+/// source may keep more or fewer).
+pub fn is_mine(id: &str, ids: &[String]) -> bool {
+    let id = id.trim_start_matches("0x").to_ascii_lowercase();
+    ids.iter().any(|m| {
+        let m = m.trim_start_matches("0x").to_ascii_lowercase();
+        let n = id.len().min(m.len());
+        n >= 6 && id[..n] == m[..n]
+    })
+}
+
+/// The reply from a weights table (`w`: the node's `getFinalityWeights` reply, or the observer's
+/// `finality.weights` with `finality` beside it), the observer's `finality` block (params and the locked index), the
+/// public stats, and this machine's key ids. Pure.
+pub fn shape(w: &Value, finality: &Value, stats: &Value, ids: &[String], source: &str, read_at: f64) -> Value {
+    let params = if w.get("params").is_some() { get(w, &["params"]) } else { get(finality, &["params"]) };
+    let mut keys: Vec<Value> = get(w, &["keys"]).as_array().map(|a| a.iter().map(key_row).collect()).unwrap_or_default();
+    keys.sort_by(|a, b| u(&b["blocks"]).cmp(&u(&a["blocks"])).then_with(|| a["id"].as_str().cmp(&b["id"].as_str())));
+    let mut mine: Vec<Value> = Vec::new();
+    for (i, k) in keys.iter().enumerate() {
+        if is_mine(k["id"].as_str().unwrap_or(""), ids) {
+            let mut m = k.clone();
+            m["rank"] = json!(i + 1);
+            mine.push(m);
+        }
+    }
+    let best = mine.iter().min_by_key(|m| u(&m["rank"])).cloned();
+    let reward = get(stats, &["block_reward"]);
+    let latest_locked = if finality.get("latest_locked_index").is_some() { u(get(finality, &["latest_locked_index"])) } else { u(get(get(stats, &["finality"]), &["latest_locked_index"])) };
+    let active = match finality.get("active").or_else(|| finality.get("finality_active")) { Some(a) => a.as_bool().unwrap_or(false), None => get(get(stats, &["finality"]), &["active"]).as_bool().unwrap_or(false) };
+    json!({
+        "ok": true,
+        "source": source,
+        "read_at": read_at,
+        "rpc": {
+            "weights": "getFinalityWeights",
+            "checkpoints": "getFinalityCheckpoints",
+            "stats": "/api/stats",
+            "relay": if source == "node" { "" } else { "igneum.network/api/live (the observer's copy of the node's reply)" }
+        },
+        "params": {
+            "dust": u(get(params, &["dust"])),
+            "weight_window": u(get(params, &["weightWindow", "weight_window"])),
+            "presence_window": u(get(params, &["presenceWindow", "presence_window"])),
+            "checkpoint_interval": u(get(params, &["checkpointInterval", "checkpoint_interval"])),
+            "min_daa": u(get(params, &["minDaa", "min_daa"])),
+        },
+        "checkpoint_index": u(get(w, &["checkpointIndex", "checkpoint_index"])),
+        "daa_score": u(get(w, &["daaScore", "daa_score"])),
+        "latest_locked_index": latest_locked,
+        "next_index": u(get(finality, &["nextIndex", "next_index"])),
+        "finality_active": active,
+        "total_weight": u(get(w, &["totalWeight", "total_weight"])),
+        "active_weight": num(get(w, &["activeWeight", "active_weight"])),
+        "voters": u(get(w, &["voters"])),
+        "keys_listed": keys.len(),
+        "keys_cap": if source == "node" { 0 } else { OBSERVER_KEYS_CAP },
+        "network": {
+            "hashrate_hps": num(get(stats, &["hashrate"])),
+            "miner_ign_per_block": num(get(reward, &["miner_ign"])),
+            "ign_per_block": num(get(reward, &["ign"])),
+            "ramp_factor": num(get(reward, &["ramp_factor"])),
+            "daa": u(get(stats, &["daa"])),
+            "blocks_per_day_measured": u(get(stats, &["blocks_per_day_measured"])),
+            "bps": 1,
+            "stale": get(stats, &["stale"]).as_bool().unwrap_or(stats.is_null()),
+        },
+        "mine": mine,
+        "best": best,
+    })
+}
+
+fn curl_json(url: &str) -> Option<Value> {
+    let out = crate::detect::run_timeout(Command::new(crate::platform::tool("curl")).args(["-s", "--max-time", "6", url]), None, Duration::from_secs(8))?;
+    serde_json::from_str(out.trim()).ok()
+}
+
+/// `https://igneum.network/api/live` -> `https://igneum.network/api/stats`
+pub fn stats_api_from(live_api: &str) -> String {
+    match live_api.strip_suffix("/api/live") {
+        Some(base) => format!("{base}/api/stats"),
+        None => String::new(),
+    }
+}
+
+/// The reply for the dashboard, cached 10 s: the node first, the observer second, `{ok:false}` with the reason when
+/// neither answers.
+pub fn fetch(evm_port: u16, live_api: &str, ids: &[String]) -> Value {
+    if let Some((at, v)) = CACHE.lock().unwrap().as_ref() {
+        if at.elapsed() < TTL {
+            let mut c = v.clone();
+            c["cached_age_s"] = json!(at.elapsed().as_secs_f64().round());
+            return c;
+        }
+    }
+    let now = crate::platform::unix_now_f();
+    let stats = if live_api.is_empty() { None } else { curl_json(&stats_api_from(live_api)) };
+    let stats = stats.unwrap_or(Value::Null);
+    let reply = match crate::extnode::rpc(evm_port, "igneum_getFinalityWeights", json!([]), Duration::from_secs(4)) {
+        Some(w) if w.get("keys").is_some() => shape(&w, &Value::Null, &stats, ids, "node", now),
+        _ => match if live_api.is_empty() { None } else { curl_json(&crate::live::url_for(live_api, 60)) } {
+            Some(live) => {
+                let fin = get(&live, &["finality"]);
+                let w = get(fin, &["weights"]);
+                if w.get("keys").is_some() { shape(w, fin, &stats, ids, "observer", now) } else { json!({ "ok": false, "error": "the observer carries no finality weights yet", "source": "observer" }) }
+            }
+            None => json!({ "ok": false, "error": if live_api.is_empty() { "no observer address in this build and the node has no igneum_getFinalityWeights" } else { "neither the node nor the observer answered" }, "source": "" }),
+        },
+    };
+    *CACHE.lock().unwrap() = Some((Instant::now(), reply.clone()));
+    reply
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn observer_live() -> Value {
+        json!({
+            "ok": true,
+            "state": { "hashes_per_second_estimate": 764944722 },
+            "finality": {
+                "supported": true, "active": true, "next_index": 8496, "latest_locked_index": 8495,
+                "params": { "dust": 5, "minDaa": 7200, "aggregators": 8, "weightWindow": 7200, "presenceWindow": 20, "checkpointDepth": 20, "equivocationBan": 7200, "checkpointInterval": 30 },
+                "weights": {
+                    "checkpoint_index": 8495, "total_weight": 6000, "active_weight": 5900.5, "voters": 14,
+                    "keys": [
+                        { "id": "6e80f3ef", "voter": true, "blocks": 680, "revealed": true, "participation": 1, "stripped_until_daa": 0 },
+                        { "id": "9e4ba6b0", "voter": true, "blocks": 559, "revealed": true, "participation": 1, "stripped_until_daa": 0 },
+                        { "id": "8fafda27", "voter": true, "blocks": 61, "revealed": true, "participation": 0.95, "stripped_until_daa": 0 },
+                        { "id": "00000001", "voter": false, "blocks": 3, "revealed": false, "participation": 0, "stripped_until_daa": 0 }
+                    ]
+                }
+            }
+        })
+    }
+    fn stats() -> Value {
+        json!({ "ok": true, "stale": false, "daa": 266454, "hashrate": 764944722, "blocks_per_day_measured": 92280, "block_reward": { "miner_ign": "4.88044084", "ign": "6.10055105", "ramp_factor": 0.192519 }, "finality": { "active": true, "latest_locked_index": 8495 } })
+    }
+
+    #[test]
+    fn the_observer_relay_shapes_into_the_node_fields_with_our_rank() {
+        let live = observer_live();
+        let fin = &live["finality"];
+        let r = shape(&fin["weights"], fin, &stats(), &["8fafda27".into()], "observer", 1.0);
+        assert_eq!(r["ok"], true);
+        assert_eq!(r["source"], "observer");
+        assert_eq!(r["params"]["dust"], 5);
+        assert_eq!(r["params"]["weight_window"], 7200);
+        assert_eq!(r["params"]["presence_window"], 20);
+        assert_eq!(r["latest_locked_index"], 8495);
+        assert_eq!(r["finality_active"], true);
+        assert_eq!(r["voters"], 14);
+        assert_eq!(r["keys_listed"], 4);
+        assert_eq!(r["keys_cap"], 64);
+        assert_eq!(r["network"]["hashrate_hps"], 764944722.0);
+        assert_eq!(r["network"]["miner_ign_per_block"], 4.88044084);
+        assert_eq!(r["mine"].as_array().unwrap().len(), 1);
+        assert_eq!(r["mine"][0]["rank"], 3);
+        assert_eq!(r["mine"][0]["blocks"], 61);
+        assert_eq!(r["mine"][0]["voter"], true);
+        assert_eq!(r["best"]["id"], "8fafda27");
+        assert!(r["rpc"]["relay"].as_str().unwrap().contains("observer"));
+    }
+
+    #[test]
+    fn the_node_reply_in_camel_case_shapes_the_same_and_names_no_relay() {
+        let w = json!({
+            "params": { "checkpointInterval": 30, "checkpointDepth": 20, "weightWindow": 2592000, "dust": 100, "presenceWindow": 240, "aggregators": 8, "equivocationBan": 2592000, "minDaa": 7200 },
+            "checkpointIndex": 184220, "checkpointHash": "ab", "daaScore": 1284117, "totalWeight": 2000000, "activeWeight": 1900000.0, "voters": 1204,
+            "keys": [
+                { "keyHash": "8fafda27aa11bb22cc33dd44", "pubkey": "a1", "blocks": 2592, "voter": true, "participation": 1.0, "strippedUntilDaa": 0 },
+                { "keyHash": "0000000100000000", "pubkey": "", "blocks": 44, "voter": false, "participation": 0.0, "strippedUntilDaa": 0 }
+            ]
+        });
+        let r = shape(&w, &Value::Null, &stats(), &["8fafda27".into()], "node", 2.0);
+        assert_eq!(r["source"], "node");
+        assert_eq!(r["keys_cap"], 0);
+        assert_eq!(r["params"]["dust"], 100);
+        assert_eq!(r["params"]["weight_window"], 2592000);
+        assert_eq!(r["checkpoint_index"], 184220);
+        assert_eq!(r["mine"][0]["id"], "8fafda27");
+        assert_eq!(r["mine"][0]["rank"], 1);
+        assert_eq!(r["mine"][0]["revealed"], true);
+        assert_eq!(r["rpc"]["relay"], "");
+        // the locked index falls back to the public stats when the node reply carries no checkpoints block
+        assert_eq!(r["latest_locked_index"], 8495);
+    }
+
+    #[test]
+    fn a_machine_with_no_key_in_the_table_has_no_rank() {
+        let live = observer_live();
+        let fin = &live["finality"];
+        let r = shape(&fin["weights"], fin, &Value::Null, &["deadbeef".into()], "observer", 1.0);
+        assert_eq!(r["mine"].as_array().unwrap().len(), 0);
+        assert!(r["best"].is_null());
+        assert_eq!(r["network"]["stale"], true);
+        assert_eq!(r["network"]["hashrate_hps"], 0.0);
+    }
+
+    #[test]
+    fn id_matching_takes_a_prefix_of_six_or_more() {
+        assert!(is_mine("8fafda27", &["8fafda27aa11".into()]));
+        assert!(is_mine("0x8fafda27aa", &["8fafda27".into()]));
+        assert!(!is_mine("8fafd", &["8fafda27".into()]));
+        assert!(!is_mine("8fafda28", &["8fafda27".into()]));
+        assert_eq!(stats_api_from("https://igneum.network/api/live"), "https://igneum.network/api/stats");
+        assert_eq!(stats_api_from(""), "");
+    }
+}

app/igneum-app/src/config.rs

@@ -39,6 +39,15 @@ pub struct CardPref {
     pub sweep_class: String,
     #[serde(default)]
     pub sweep_source: String,
+    /// Miner UI 4 (6 October 2026): this card's goal (efficiency | balanced | rate); empty = the global tune_goal
+    #[serde(default)]
+    pub tune_goal: String,
+    /// the untuned point the last FULL plan measured first (its step 0), kept across confirm plans so the row can
+    /// read "saves 84 W, 0.15% of rate"; 0 = never measured
+    #[serde(default)]
+    pub sweep_before_watts: f64,
+    #[serde(default)]
+    pub sweep_before_mhs: f64,
     /// Ember 2: the memory clock the last tune chose (0 = the driver's default)
     #[serde(default)]
     pub sweep_mem_mhz: u32,
@@ -120,6 +129,14 @@ pub struct Settings {
     /// on when the machine can prove, never switching an explicit on back off). Older installs apply it at their next start.
     #[serde(default)]
     pub prove_default_applied: bool,
+    /// miner-ui-5 (7 October 2026): the public address profile on the site is behind this opt-in; off by default, and
+    /// the switch's words say what becomes public (the key ids, the blocks, the weight rank, the card model).
+    #[serde(default)]
+    pub profile_public: bool,
+    /// ui-ota (7 October 2026, src/uiota.rs): "Use the built-in interface": the embedded dashboard serves even when an
+    /// over-the-air interface bundle is active. Default off.
+    #[serde(default)]
+    pub ui_builtin: bool,
 }
 
 fn one() -> u32 {
@@ -134,7 +151,7 @@ fn yes() -> bool {
 
 impl Default for Settings {
     fn default() -> Settings {
-        Settings { setup_done: false, address: String::new(), address_source: String::new(), key_saved: false, identities: 1, cards: HashMap::new(), display_name: String::new(), vote: true, paused: false, accepted_total: 0, auto_update: true, remote_jobs: true, prove: false, sweep: true, power_control: false, tune_goal: "balanced".into(), power_price_pence: 0.0, tune_climb: false, installed_at: 0, dev_fee: true, fee_total: 0, proof_verify_trust: false, prove_default_applied: false }
+        Settings { setup_done: false, address: String::new(), address_source: String::new(), key_saved: false, identities: 1, cards: HashMap::new(), display_name: String::new(), vote: true, paused: false, accepted_total: 0, auto_update: true, remote_jobs: true, prove: false, sweep: true, power_control: false, tune_goal: "balanced".into(), power_price_pence: 0.0, tune_climb: false, installed_at: 0, dev_fee: true, fee_total: 0, proof_verify_trust: false, prove_default_applied: false, profile_public: false, ui_builtin: false }
     }
 }
 
@@ -357,8 +374,9 @@ impl Runtime {
         let p2p_port = env("IGNEUM_APP_P2P_PORT").and_then(|v| v.parse().ok()).unwrap_or(26611);
         let peers = match std::env::var("IGNEUM_APP_PEERS") {
             Ok(v) => v.split(',').map(|s| s.trim().to_string()).filter(|s| !s.is_empty()).collect(),
-            // the public seed node first, then the project lead's Mac on the house LAN (devnet only)
-            Err(_) if network == "devnet" => vec!["188.245.5.161:26611".to_string(), "192.168.68.64:26611".to_string()],
+            // the public seed node first, then the build box's hand nodes (main's decision (b), 6 October 2026, 19:1x UTC:
+            // the hands move off the project lead's Mac to igneum-build-1), then the project lead's Mac on the house LAN (devnet only)
+            Err(_) if network == "devnet" => vec!["188.245.5.161:26611".to_string(), "188.40.146.49:26611".to_string(), "192.168.68.64:26611".to_string()],
             Err(_) => vec![],
         };
         let unsynced_mining = env("IGNEUM_APP_UNSYNCED").map(|v| v == "1").unwrap_or(false);

app/igneum-app/src/ember.rs

@@ -906,6 +906,33 @@ pub fn tuned_line(mhs: f64, watts: f64, eff: f64) -> String {
     format!("Tuned: {mhs:.1} MH/s at {watts:.0} W ({eff:.3} MH/W)")
 }
 
+/// Miner UI 4 (6 October 2026): a card's own goal when set, else the global one.
+pub fn goal_for(card_goal: &str, global: &str) -> Goal {
+    Goal::parse(if card_goal.trim().is_empty() { global } else { card_goal })
+}
+
+/// (D) May a step be SET on this card? Measure-only (no control: Apple, NVIDIA without Power control, an AMD card
+/// whose probe gave no tune line) sets nothing: the run notices the missing acknowledgement and measures. An AMD
+/// card also needs its ADLX ordinal. 6 October 2026, PC 1 17:57Z: a measure-only 9070 XT was sent a set, refused.
+pub fn may_set(vendor: &str, tune_control: bool, amd_ordinal: i64) -> bool {
+    match vendor {
+        "nvidia" => tune_control,
+        "amd" => tune_control && amd_ordinal >= 0,
+        _ => false,
+    }
+}
+
+/// (E) The row's words while a back-off from a failed tune holds: when the retry comes and why it stopped.
+pub fn retry_note(remaining_s: u64, last_note: &str) -> String {
+    let mins = (remaining_s + 59) / 60;
+    let why = last_note.trim_start_matches("tuning stopped: ").trim_start_matches("tuning: ").trim();
+    if why.is_empty() {
+        format!("tuning: retry in {mins} min")
+    } else {
+        format!("tuning: retry in {mins} min ({why})")
+    }
+}
+
 /// The row's line for a baseline (measure-only) result: the card was measured as it runs, nothing was set.
 /// (6 October 2026: PC 1's rows read "Tuned: 114.2 MH/s at 305 W" for a baseline, which is not a tune.)
 pub fn measured_line(mhs: f64, watts: f64, eff: f64) -> String {
@@ -1007,6 +1034,26 @@ mod tests {
         assert!(Run::applied(&step, Readback { limit_w: 90.0, acked: false }, 100.0));
     }
 
+    #[test]
+    fn a_card_goal_overrides_the_global_goal_and_empty_follows_it() {
+        assert_eq!(goal_for("", "balanced"), Goal::Balanced);
+        assert_eq!(goal_for("rate", "balanced"), Goal::MaxRate);
+        assert_eq!(goal_for("efficiency", "rate"), Goal::Efficiency);
+        assert_eq!(goal_for("  ", "efficiency"), Goal::Efficiency);
+    }
+
+    #[test]
+    fn a_measure_only_card_is_never_set_and_a_back_off_says_when_the_retry_comes() {
+        assert!(!may_set("amd", false, 1), "the probe gave no tune line: measure only");
+        assert!(may_set("amd", true, 1));
+        assert!(!may_set("amd", true, -1), "no ADLX ordinal");
+        assert!(!may_set("nvidia", false, -1), "Power control off: measure only");
+        assert!(may_set("nvidia", true, -1));
+        assert!(!may_set("apple", true, -1));
+        assert_eq!(retry_note(3599, "tuning stopped: the card refused the setting (see the log)"), "tuning: retry in 60 min (the card refused the setting (see the log))");
+        assert_eq!(retry_note(30, ""), "tuning: retry in 1 min");
+    }
+
     #[test]
     fn a_baseline_result_reads_measured_and_a_tune_reads_tuned() {
         assert_eq!(result_line(PlanKind::Baseline, 114.2, 305.0, 0.3744), "Measured: 114.2 MH/s at 305 W (0.374 MH/W)");

app/igneum-app/src/engine.rs

@@ -16,6 +16,9 @@ use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+/// miner-ui-5: a signing streak breaks when no VOTE line comes for this long (the devnet's presence window, 20
+/// checkpoints of 30 s; the chain-side fact is `getFinalityWeights.keys[].participation`, this is the local reading)
+pub const LADDER_GAP_S: f64 = 600.0;
 const POW_EPOCH_BLOCKS: u64 = 3_600;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -48,6 +51,13 @@ pub enum Cmd {
     WorkerBuilt(usize, Result<PathBuf, String>),
     /// local minus the latest block's timestamp, seconds (from the node's EVM RPC)
     ClockSample(f64),
+    /// another node holds the app's ports: what it answered (src/extnode.rs)
+    ExternalNode(crate::extnode::Check),
+    /// the node's own description over RPC (igneum_getNodeInfo), every 30 s
+    NodeInfo(crate::extnode::Check),
+    /// the network's view for the merge check (src/merge.rs): the highest blue score the observer shows, and the unix
+    /// ms of the newest block it marks as ours
+    NetView { sink_blue: u64, ours_ts_ms: Option<i64> },
     /// local minus an HTTPS Date header, seconds; None when the check failed
     ClockHttps(Option<f64>),
     ClockCheck,
@@ -77,11 +87,19 @@ pub enum Cmd {
     TuneProgress(Value),
     /// Ember 2: Settings > goal, electricity price, the hill-climb switch
     TuneGoal(Option<String>, Option<f64>, Option<bool>),
+    /// one card's goal override (key, goal; "" = back to the global goal)
+    TuneCardGoal(String, String),
     /// restart the node with the verifier decided again (src/verifier.rs): the trust setting changed, or the
     /// prover found a host that was not there when the node started
     RestartNode(String),
     /// quit, with its source (the log names it: C35, 5 October 2026, two unexplained quits)
     Quit(&'static str),
+    /// ui-ota (src/uiota.rs): the download thread's result; the server served a bundle's index.html (its version);
+    /// the page's health ping (None) or its first-paint error; Settings > Use the built-in interface
+    UiOta(crate::uiota::Event),
+    UiPageLoaded(String),
+    UiHealth(Option<String>),
+    UiBuiltin(bool),
 }
 
 pub struct Shared {
@@ -94,6 +112,8 @@ pub struct Shared {
     pub runtime: Runtime,
     pub packaged: Packaged,
     cmd_tx: Mutex<Sender<Cmd>>,
+    /// ui-ota: the folder the server serves the dashboard from (None = the files embedded in the binary)
+    ui_dir: Mutex<Option<PathBuf>>,
     pub started: Instant,
     engine_log: Mutex<Option<std::fs::File>>,
     /// the app log's path: the one the uploader sends (main.rs names it; the engine must not guess the stamp)
@@ -101,12 +121,17 @@ pub struct Shared {
     port: std::sync::atomic::AtomicU16,
     /// set once `state_json` has logged a serialisation error (one line, not one per poll)
     state_error_logged: std::sync::atomic::AtomicBool,
+    /// miner-ui-5: the machine's own ladder record (src/ladder.rs), `<app dir>/ladder.json`
+    pub ladder: Mutex<crate::ladder::Ladder>,
+    pub ladder_path: PathBuf,
 }
 
 impl Shared {
     pub fn new(token: String, runtime: Runtime, packaged: Packaged, settings: Settings, cmd_tx: Sender<Cmd>, engine_log: Option<std::fs::File>, log_path: PathBuf) -> Shared {
         let settings_path = runtime.app_dir.join("settings.json");
         let wallet_path = runtime.app_dir.join("wallet.json");
+        let ladder_path = runtime.app_dir.join("ladder.json");
+        let ladder = crate::ladder::Ladder::load(&ladder_path);
         let mut st = State { version: VERSION.into(), ..Default::default() };
         st.network = runtime.network.clone();
         st.chain = if runtime.network == "devnet" { "devnet v4".into() } else { format!("{} (private)", runtime.network) };
@@ -118,12 +143,13 @@ impl Shared {
         st.setup_done = settings.setup_done;
         st.phase = if settings.setup_done { "dashboard".into() } else { "welcome".into() };
         st.node.state = "stopped".into();
+        st.node.tip_age_s = -1.0;
         st.mining.state = "idle".into();
         st.mining.paused = settings.paused;
         st.mining.accepted_total = settings.accepted_total;
         st.mining.fee_total = settings.fee_total;
         st.address = address_state(&settings, &wallet_path);
-        st.settings = crate::state::SettingsState { identities: settings.identities, vote: settings.vote, start_at_login: crate::platform::start_at_login_is_on(), auto_update: settings.auto_update, remote_jobs: settings.remote_jobs, prove: settings.prove, sweep: settings.sweep, power_control: settings.power_control, power_note: String::new(), tuning_off: false, tuning_note: String::new(), tune_goal: settings.tune_goal.clone(), power_price_pence: settings.power_price_pence, tune_climb: settings.tune_climb, tune_period_s: crate::ember::PERIOD_S, dev_fee: settings.dev_fee, proof_verify_trust: settings.proof_verify_trust };
+        st.settings = crate::state::SettingsState { identities: settings.identities, vote: settings.vote, start_at_login: crate::platform::start_at_login_is_on(), auto_update: settings.auto_update, remote_jobs: settings.remote_jobs, prove: settings.prove, sweep: settings.sweep, power_control: settings.power_control, power_note: String::new(), tuning_off: false, tuning_note: String::new(), tune_goal: settings.tune_goal.clone(), power_price_pence: settings.power_price_pence, tune_climb: settings.tune_climb, tune_period_s: crate::ember::PERIOD_S, dev_fee: settings.dev_fee, proof_verify_trust: settings.proof_verify_trust, profile_public: settings.profile_public, ui_builtin: settings.ui_builtin };
         st.dev_fee = crate::state::DevFeeState { on: settings.dev_fee, percent: if settings.dev_fee { 1 } else { 0 }, address: String::new(), line: String::new() };
         st.live_page = packaged.live_page.clone();
         st.finality.message = "waiting for the miner".into();
@@ -140,14 +166,27 @@ impl Shared {
             runtime,
             packaged,
             cmd_tx: Mutex::new(cmd_tx),
+            ui_dir: Mutex::new(None),
             started: Instant::now(),
             engine_log: Mutex::new(engine_log),
             log_path,
             port: std::sync::atomic::AtomicU16::new(0),
             state_error_logged: std::sync::atomic::AtomicBool::new(false),
+            ladder: Mutex::new(ladder),
+            ladder_path,
         }
     }
 
+    /// miner-ui-5: the ladder record to disk (a few KB; after a block, a lock or a paid shard)
+    pub fn save_ladder(&self) {
+        self.ladder.lock().unwrap().save(&self.ladder_path);
+    }
+    /// miner-ui-5: a paid shard record of ours (src/prover.rs) joins the ladder's shard list
+    pub fn ladder_shard_paid(&self, block: u64, shard: u64, wei: u128) {
+        self.ladder.lock().unwrap().on_shard_paid(crate::platform::unix_now_f(), block, shard, wei);
+        self.save_ladder();
+    }
+
     /// The first line of every upload, so the console's Machines tab parses it without guessing:
     /// IGNEUM-APP version=<v> machine=<id8> platform=<os> node=<igneumd version>. Logged at every engine start too,
     /// so the restart after an OTA apply carries it again.
@@ -163,6 +202,22 @@ impl Shared {
         self.port.load(std::sync::atomic::Ordering::Relaxed)
     }
 
+    /// A Shared over a scratch folder for the unit tests that need one (src/uiota.rs): no node, no window, a channel
+    /// nobody reads (send drops the command), the defaults everywhere else.
+    #[cfg(test)]
+    pub fn for_tests(dir: PathBuf) -> Arc<Shared> {
+        let _ = std::fs::create_dir_all(&dir);
+        let (tx, _rx) = channel();
+        let runtime = crate::config::Runtime { network: "devnet".into(), rpc_port: 0, p2p_port: 0, peers: vec![], unsynced_mining: false, devnet_suffix: None, node_dir: dir.join("node"), app_dir: dir.clone(), log_dir: dir.join("logs"), status_secs: 30, sweep_only: true, host: "test".into(), machine_id: "0123456789abcdef".into() };
+        Arc::new(Shared::new("t".into(), runtime, crate::config::Packaged::default(), Settings::default(), tx, None, dir.join("app.log")))
+    }
+    /// ui-ota: what the server serves the dashboard from; None = the embedded files
+    pub fn ui_dir(&self) -> Option<PathBuf> {
+        self.ui_dir.lock().unwrap().clone()
+    }
+    pub fn set_ui_dir(&self, d: Option<PathBuf>) {
+        *self.ui_dir.lock().unwrap() = d;
+    }
     pub fn send(&self, c: Cmd) {
         let _ = self.cmd_tx.lock().unwrap().send(c);
     }
@@ -187,6 +242,7 @@ impl Shared {
         st.now = crate::platform::unix_now_f();
         st.uptime_s = self.started.elapsed().as_secs();
         st.events = self.rings.lock().unwrap().events.iter().cloned().collect();
+        st.ladder = self.ladder.lock().unwrap().state(st.now, LADDER_GAP_S);
         match serde_json::to_value(st) {
             Ok(v) => v,
             Err(e) => {
@@ -323,7 +379,7 @@ impl Shared {
         Ok(json!({ "ok": true }))
     }
 
-    pub fn apply_settings(&self, identities: Option<u32>, vote: Option<bool>, login: Option<bool>, address: Option<&str>, display_name: Option<&str>, dev_fee: Option<bool>, proof_verify_trust: Option<bool>) -> Result<Value, String> {
+    pub fn apply_settings(&self, identities: Option<u32>, vote: Option<bool>, login: Option<bool>, address: Option<&str>, display_name: Option<&str>, dev_fee: Option<bool>, proof_verify_trust: Option<bool>, profile_public: Option<bool>) -> Result<Value, String> {
         let mut restart = Vec::new();
         let mut restart_node: Option<String> = None;
         {
@@ -357,6 +413,12 @@ impl Shared {
                     restart_node = Some(if v { "proof trust mode on (devnet only)".into() } else { "proof trust mode off".into() });
                 }
             }
+            if let Some(v) = profile_public {
+                if v != s.profile_public {
+                    s.profile_public = v;
+                    self.event("info", if v { "public profile on: your key ids, blocks, weight rank and card model may be shown on igneum.network" } else { "public profile off: the address page stays unlisted" });
+                }
+            }
             if let Some(a) = address {
                 let a = a.trim().to_ascii_lowercase();
                 if !a.is_empty() && a != s.address {
@@ -376,6 +438,7 @@ impl Shared {
             st.settings.vote = s.vote;
             st.settings.dev_fee = s.dev_fee;
             st.settings.proof_verify_trust = s.proof_verify_trust;
+            st.settings.profile_public = s.profile_public;
             st.dev_fee.on = s.dev_fee;
             st.dev_fee.percent = if s.dev_fee { 1 } else { 0 };
             st.address = address_state(&s, &self.wallet_path);
@@ -532,6 +595,18 @@ pub struct Engine {
     lines_tx: Sender<Line>,
     node: Option<Proc>,
     node_external: bool,
+    /// the merge check (src/merge.rs): the network's sinks as last seen, when one of our blocks last appeared in the
+    /// network's view, the merge depth from the node's params, when mining with a synced node began, the last poll
+    merge_sinks: Vec<u64>,
+    merge_ours_seen: Option<Instant>,
+    merge_depth: u64,
+    merge_mining_since: Option<Instant>,
+    merge_view_at: Instant,
+    /// the ports are held by a node this app refused (other rules or network): re-checked, the app takes the ports when it leaves
+    node_refused: bool,
+    /// when the other node's port stopped answering (engine seconds), None while it answers
+    external_gone_since: Option<f64>,
+    node_info_at: Instant,
     node_restart_at: Option<Instant>,
     /// resume rule (5 October 2026): when due, every enabled card must be mining or its name goes to the log
     resume_check_at: Option<Instant>,
@@ -557,6 +632,8 @@ pub struct Engine {
     last_upload: Instant,
     upload_thread: Option<std::thread::JoinHandle<()>>,
     ota: crate::ota::Updater,
+    /// the interface over the air (src/uiota.rs)
+    uiota: crate::uiota::UiOta,
     jobs: crate::jobrun::Jobs,
     /// a remote job has the miners stopped; they restart when the runner lets go
     job_hold: bool,
@@ -642,6 +719,7 @@ impl Engine {
         // labels never carry the hostname: two cloned PCs with the same COMPUTERNAME would sign with the same keys
         let label_base = format!("{}-{}", if cfg!(target_os = "macos") { "mac" } else { "win" }, shared.runtime.id8());
         let ota = crate::ota::Updater::new(&shared);
+        let uiota = crate::uiota::UiOta::new(&shared);
         let jobs = crate::jobrun::Jobs::new(&shared);
         Engine {
             shared,
@@ -651,6 +729,14 @@ impl Engine {
             lines_tx,
             node: None,
             node_external: false,
+            merge_sinks: Vec::new(),
+            merge_ours_seen: None,
+            merge_depth: 0,
+            merge_mining_since: None,
+            merge_view_at: now,
+            node_refused: false,
+            external_gone_since: None,
+            node_info_at: Instant::now() - Duration::from_secs(25),
             node_restart_at: None,
             resume_check_at: None,
             node_started_at: now,
@@ -674,6 +760,7 @@ impl Engine {
             last_upload: now,
             upload_thread: None,
             ota,
+            uiota,
             jobs,
             job_hold: false,
             stamp,
@@ -904,6 +991,10 @@ impl Engine {
                 }
             }
             Cmd::Ota(ev) => self.ota.event(&self.shared, ev),
+            Cmd::UiOta(ev) => self.uiota.event(&self.shared, ev),
+            Cmd::UiPageLoaded(v) => self.uiota.page_loaded(&v, Instant::now()),
+            Cmd::UiHealth(err) => self.uiota.health(&self.shared, err.as_deref()),
+            Cmd::UiBuiltin(on) => self.uiota.set_builtin(&self.shared, on),
             Cmd::Job(ev) => {
                 if let Some(a) = self.jobs.event(&self.shared, ev) {
                     self.job_action(a);
@@ -939,6 +1030,33 @@ impl Engine {
                     }
                 }
             }
+            Cmd::ExternalNode(check) => self.external_node_decided(check),
+            Cmd::NetView { sink_blue, ours_ts_ms } => {
+                self.merge_sinks = vec![sink_blue];
+                if let Some(ms) = ours_ts_ms {
+                    let age = (crate::platform::unix_now_f() - ms as f64 / 1000.0).max(0.0);
+                    self.merge_ours_seen = Some(Instant::now() - Duration::from_secs_f64(age.min(86_400.0)));
+                }
+            }
+            Cmd::NodeInfo(info) => {
+                // the merge depth is compiled per network (not in params): blockrate.mergeDepth when the node says, else 3,600
+                if let Some(d) = info.merge_depth { self.merge_depth = d; }
+                if info.pow_engine.as_deref() == Some("stub") {
+                    let first = self.st().node.state != "stub";
+                    let mut st = self.st();
+                    st.node.state = "stub".into();
+                    st.node.synced = false;
+                    st.node.message = "this node was built without the mining engine (stub) and refuses every real block".into();
+                    drop(st);
+                    if first { self.shared.event("error", "the node runs the stub engine, not igneum-pow: it refuses every real block. Reinstall the app (ledger N5)"); }
+                }
+                let mut st = self.st();
+                if let Some(d) = info.digest.filter(|d| d.len() >= 16) {
+                    if st.node.consensus_digest != d { st.node.consensus_digest = d; }
+                    st.node.digest_source = "rpc".into();
+                }
+                if let Some(v) = info.version { if !v.is_empty() && st.node.version.is_empty() { st.node.version = v; } }
+            }
             Cmd::ClockSample(d) => {
                 self.clock_samples.push(d);
                 if self.clock_samples.len() > 9 {
@@ -1147,6 +1265,26 @@ impl Engine {
                 }
             }
             Cmd::TuneProgress(v) => self.tune_progress(&v),
+            Cmd::TuneCardGoal(key, goal) => {
+                {
+                    let mut s = self.shared.settings.lock().unwrap();
+                    let (enabled, identities) = self.st().mining.cards.iter().find(|c| c.key == key).map(|c| (c.enabled, c.identities)).unwrap_or((true, 1));
+                    let e = s.cards.entry(key.clone()).or_insert_with(|| crate::config::CardPref { enabled, identities, ..Default::default() });
+                    e.tune_goal = goal.clone();
+                }
+                self.shared.save_settings();
+                let name = {
+                    let mut st = self.st();
+                    let c = st.mining.cards.iter_mut().find(|c| c.key == key);
+                    c.map(|c| {
+                        c.tune_goal = goal.clone();
+                        c.name.clone()
+                    })
+                };
+                if let Some(name) = name {
+                    self.shared.event("info", &format!("{name}: tune goal {}", if goal.is_empty() { "follows the global setting".to_string() } else { goal.clone() }));
+                }
+            }
             Cmd::TuneGoal(goal, price, climb) => {
                 {
                     let mut s = self.shared.settings.lock().unwrap();
@@ -1359,14 +1497,22 @@ impl Engine {
         let _ = std::fs::create_dir_all(&self.shared.runtime.log_dir);
         self.apply_power_limits("start");
         if port_open(self.shared.runtime.rpc_port) {
-            self.node_external = true;
-            self.shared.event("info", &format!("a node already answers on 127.0.0.1:{}; using it (it is not stopped by this app)", self.shared.runtime.rpc_port));
-            let mut st = self.st();
-            st.node.state = "syncing".into();
-            st.node.message = "external node".into();
-            st.proving.verifier_reason = "external node: the app did not start it, so it set no verifier".into();
-            st.proving.verifier_note = crate::verifier::note("unknown", "", "", true);
+            // another node holds the app's ports: check whose rules it runs before reading it (publish 2's read-back,
+            // 6 October 2026: the Mac read the hand node silently as its own); the answer comes back as Cmd::ExternalNode
+            let port = self.shared.runtime.rpc_port;
+            {
+                let mut st = self.st();
+                st.node.state = "starting".into();
+                st.node.source = String::new();
+                st.node.message = format!("another node holds port {port} on this machine; checking its rules");
+            }
+            self.shared.log(&format!("port {port} is held by another node; asking it for its chain id and rules before using it"));
+            let shared = self.shared.clone();
+            let evm_port = self.shared.runtime.evm_port();
+            std::thread::spawn(move || { shared.send(Cmd::ExternalNode(crate::extnode::probe(evm_port))); });
         } else {
+            crate::extnode::prune_logs(&self.shared.runtime.log_dir, "node-", 10);
+            self.set_node_mode("app", "own", "the ports were free at launch, so the app started its own node");
             self.start_node();
         }
         self.plan_miners();
@@ -1400,6 +1546,74 @@ impl Engine {
     /// The packager's consensus parameters (igneum-app.json `node_override_params`, for example the difficulty v2
     /// activation height) written to <app data>/override-params.json for --override-params-file. None when the
     /// package pins nothing, so the node runs on the network's defaults as before.
+    /// The check of another node on the app's ports came back (src/extnode.rs): use it and say so, or refuse it
+    fn external_node_decided(&mut self, check: crate::extnode::Check) {
+        let port = self.shared.runtime.p2p_port;
+        let ours = self.node_override_file().and_then(|p| std::fs::read_to_string(p).ok()).and_then(|t| serde_json::from_str::<Value>(&t).ok());
+        let network = self.shared.runtime.network.clone();
+        let d = crate::extnode::decide_on(port, ours.as_ref(), None, Some(network.as_str()), &check);
+        self.node_external = d.use_it;
+        self.node_refused = !d.use_it;
+        self.external_gone_since = None;
+        self.set_node_mode(if d.use_it { "external" } else { "none" }, if d.use_it { "external" } else { "none" }, &d.line);
+        {
+            let mut st = self.st();
+            st.node.rules_check = d.verdict.into();
+            st.node.port_note = d.line.clone();
+        }
+        if d.use_it {
+            self.shared.event(if d.verdict == "match" { "info" } else { "error" }, &d.line);
+            let mut st = self.st();
+            st.node.state = "syncing".into();
+            st.node.message = "another node on this machine".into();
+            if let Some(dg) = check.digest.filter(|x| x.len() >= 16) { st.node.consensus_digest = dg; st.node.digest_source = "rpc".into(); }
+            if let Some(v) = check.version { if !v.is_empty() { st.node.version = v; } }
+            st.proving.verifier_reason = "external node: the app did not start it, so it set no verifier".into();
+            st.proving.verifier_note = crate::verifier::note("unknown", "", "", true);
+        } else {
+            {
+                let mut st = self.st();
+                st.node.state = "stopped".into();
+                st.node.synced = false;
+                st.node.message = d.line.clone();
+            }
+            self.shared.event("error", &d.line);
+            self.shared.event("error", "mining waits: stop the other node or start this app with other ports, then open the app again");
+        }
+    }
+
+    /// Record which node the app reads (api/state node.source, node.mode, node.mode_reason).
+    fn set_node_mode(&self, source: &str, mode: &str, reason: &str) {
+        let mut st = self.st();
+        st.node.source = source.into();
+        st.node.mode = mode.into();
+        st.node.mode_reason = reason.into();
+    }
+
+    /// The other node left its ports for TAKEOVER_WAIT_S: the app starts its own node on them and says so.
+    fn take_over_ports(&mut self) {
+        let port = self.shared.runtime.rpc_port;
+        let was = if self.node_external { "the node this app was reading" } else { "the node this app refused" };
+        self.node_external = false;
+        self.node_refused = false;
+        self.external_gone_since = None;
+        let reason = format!("{was} left port {port} for {} s, so the app started its own node", crate::extnode::TAKEOVER_WAIT_S as u64);
+        self.shared.event("info", &format!("The other node went away; this app starts its own node on port {port}"));
+        self.set_node_mode("app", "own", &reason);
+        {
+            let mut st = self.st();
+            st.node.rules_check = String::new();
+            st.node.port_note = reason.clone();
+            st.node.synced = false;
+            st.node.consensus_digest = String::new();
+            st.node.digest_source = String::new();
+            st.node.version = String::new();
+        }
+        self.node_last_reading = None;
+        crate::extnode::prune_logs(&self.shared.runtime.log_dir, "node-", 10);
+        self.start_node();
+    }
+
     fn node_override_file(&self) -> Option<std::path::PathBuf> {
         if self.node_override_unusable {
             return None;
@@ -1447,6 +1661,9 @@ impl Engine {
                 let mut st = self.st();
                 st.node.pid = p.pid();
                 st.node.state = "starting".into();
+                st.node.stall_exits = 0;
+                st.node.tip_age_s = -1.0;
+                st.node.sync_cause = String::new();
                 st.node.starts = self.node_starts;
                 st.node.message = "opening the database".into();
                 st.node.restart_in_s = 0;
@@ -1642,6 +1859,11 @@ impl Engine {
         match procs::spawn(Source::Miner(card_idx), &self.bins.miner, &args, cwd.as_deref(), &log, &self.lines_tx, &envs) {
             Ok(p) => {
                 self.shared.log(&format!("miner {} started (pid {}): {}", self.miners[i].label, p.pid(), p.cmdline));
+                if self.miners[i].starts == 1 {
+                    // one Activity line per card at its first start (an OTA relaunch shows every card coming back)
+                    let name = self.st().mining.cards.get(self.miners[i].card).map(|c| c.name.clone()).unwrap_or_else(|| self.miners[i].label.clone());
+                    self.shared.event("info", &format!("{name}: worker starting (pid {})", p.pid()));
+                }
                 let mut st = self.st();
                 if let Some(c) = st.mining.cards.get_mut(card_idx) {
                     c.pid = p.pid();
@@ -2219,8 +2441,23 @@ impl Engine {
             if c.tune_control && c.vendor == "nvidia" && !power_control && !forced {
                 // measure-only until Power control is on; the baseline plan covers it below
             }
-            if self.sweep_retry.get(&c.index).map(|t| now < *t).unwrap_or(false) {
-                continue;
+            // (E) 6 October 2026, PC 1 18:18Z: three "Tune now" requests sat behind the hour's back-off from the
+            // 17:55 failures and the rows said "queued" with no start; an explicit request now clears the back-off,
+            // and a held card's row says when the retry comes
+            if let Some(t) = self.sweep_retry.get(&c.index).copied() {
+                if now < t {
+                    if forced {
+                        self.sweep_retry.remove(&c.index);
+                    } else {
+                        if c.sweep_pct == 0 || c.sweep_note.starts_with("tuning stopped") {
+                            let note = crate::ember::retry_note((t - now).as_secs(), &c.sweep_note);
+                            if let Some(cc) = self.st().mining.cards.get_mut(c.index) {
+                                cc.sweep_note = note;
+                            }
+                        }
+                        continue;
+                    }
+                }
             }
             let stable = self.miners.iter().find(|m| m.card == c.index).map(|m| m.proc.as_ref().map(|p| p.started.elapsed() >= Duration::from_secs(crate::ember::STABLE_S)).unwrap_or(false) && m.last_status.is_some()).unwrap_or(false);
             let wait = if c.state != "mining" {
@@ -2399,7 +2636,8 @@ impl Engine {
         let full_due = self.tune_full_due.remove(&idx);
         let (goal, climb_on) = {
             let s = self.shared.settings.lock().unwrap();
-            (crate::ember::Goal::parse(&s.tune_goal), s.tune_climb)
+            // the card's own goal when set, else the global one
+            (crate::ember::goal_for(s.cards.get(&c.key).map(|p| p.tune_goal.as_str()).unwrap_or(""), &s.tune_goal), s.tune_climb)
         };
         let plan = if let Some(why) = control.as_ref() {
             if let Some(cc) = self.st().mining.cards.get_mut(idx) {
@@ -2567,16 +2805,47 @@ impl Engine {
                 }
                 let dev = device.to_string();
                 let cmd = format!("{seq}0 dev {dev}\n{seq}1 pl {w}\n{seq}2 {}\n{seq}3 {}\n", if clock > 0 { format!("lgc {clock}") } else { "rgc".to_string() }, if mem > 0 { format!("lmc {mem}") } else { "rmc".to_string() });
-                let _ = std::fs::write(self.helper_cmd_dir().join("cmd.txt"), cmd);
-                // the helper polls twice a second and nvidia-smi answers within a second or two
+                let dir = self.helper_cmd_dir();
+                let is_task = self.sweep_helper_is_task;
+                // 6 October 2026, PC 1: (B) the task's helper had exited while the engine's flag still said it ran,
+                // so commands went to nobody and a blind 4-second sleep called them acknowledged; (C) the first
+                // request of the first tune was written in the same second the helper started, and the helper
+                // skipped it as stale. Now, in the task case: the helper's heartbeat says whether it runs; the task
+                // is started and a fresh heartbeat awaited BEFORE the command is written; and the acknowledgement
+                // is the helper's own log line for this sequence (`<seq>3 nvidia-smi ...`), read for up to 15 s;
+                // a missing line is a failure with that reason
+                let want = format!(" {seq}3 nvidia-smi");
+                let log_file = dir.join("helper.log");
                 std::thread::spawn(move || {
-                    std::thread::sleep(Duration::from_secs(4));
-                    shared.send(Cmd::TuneSet(seq, Ok("helper".into())));
+                    if is_task {
+                        if let Err(e) = crate::powertask::ensure_running(&dir, Duration::from_secs(12)) {
+                            shared.send(Cmd::TuneSet(seq, Err(e)));
+                            return;
+                        }
+                    }
+                    let _ = std::fs::create_dir_all(&dir);
+                    let _ = std::fs::write(dir.join("cmd.txt"), cmd);
+                    let until = Instant::now() + Duration::from_secs(if is_task { 15 } else { 6 });
+                    loop {
+                        std::thread::sleep(Duration::from_millis(500));
+                        let text = std::fs::read_to_string(&log_file).unwrap_or_default();
+                        if let Some(line) = text.lines().rev().find(|l| l.contains(&want)) {
+                            shared.send(Cmd::TuneSet(seq, Ok(format!("helper: {}", line.trim()))));
+                            return;
+                        }
+                        if Instant::now() >= until {
+                            shared.send(Cmd::TuneSet(seq, Err(format!("the helper did not run sequence {seq} within {} s (no line in {})", if is_task { 15 } else { 6 }, log_file.display()))));
+                            return;
+                        }
+                    }
                 });
             }
             "amd" => {
                 let Some(exe) = self.bins.telemetry.clone() else { return };
-                if c.amd_ordinal < 0 {
+                // (D) 6 October 2026, PC 1 17:57Z: a measure-only card (the probe gave no tune line) was still sent a
+                // set, which the helper refused and the tune stopped; measure only means nothing is set, the run
+                // notices the missing acknowledgement and measures
+                if !crate::ember::may_set("amd", c.tune_control, c.amd_ordinal) {
                     return;
                 }
                 let n = c.amd_ordinal.to_string();
@@ -2792,6 +3061,14 @@ impl Engine {
             e.sweep_driver = c.driver.clone();
             e.sweep_class = c.program_class.clone();
             e.sweep_source = kind.name().into();
+            if kind == crate::ember::PlanKind::Full {
+                if let Some(b) = run.rows.first() {
+                    e.sweep_before_watts = b.watts;
+                    e.sweep_before_mhs = b.mhs;
+                    c.tune_before_watts = b.watts;
+                    c.tune_before_mhs = b.mhs;
+                }
+            }
             if !c.pinned && kind != crate::ember::PlanKind::Baseline {
                 e.power_pct = row.point.power_pct;
             }
@@ -2907,6 +3184,25 @@ impl Engine {
             self.last_awake = now;
             crate::platform::keep_awake_tick();
         }
+        if self.running && self.node.is_some() && !self.miners.is_empty() && now.duration_since(self.merge_view_at) >= Duration::from_secs(30) {
+            self.merge_view_at = now;
+            let shared = self.shared.clone();
+            let live_api = std::env::var("IGNEUM_APP_LIVE_API").unwrap_or_else(|_| crate::ota::live_api_from(&self.shared.packaged.live_page));
+            let ids: std::collections::HashSet<String> = self.st().mining.cards.iter().flat_map(|c| c.ids.iter().cloned()).collect();
+            if !live_api.is_empty() {
+                std::thread::spawn(move || {
+                    if let Some((sink_blue, ours_ts_ms)) = crate::merge::view_of(&crate::live::fetch(&live_api, 600, &ids)) {
+                        shared.send(Cmd::NetView { sink_blue, ours_ts_ms });
+                    }
+                });
+            }
+        }
+        if self.running && (self.node_external || self.node.is_some()) && now.duration_since(self.node_info_at) >= Duration::from_secs(30) {
+            self.node_info_at = now;
+            let shared = self.shared.clone();
+            let evm_port = self.shared.runtime.evm_port();
+            std::thread::spawn(move || { let c = crate::extnode::probe(evm_port); if c.digest.is_some() || c.version.is_some() { shared.send(Cmd::NodeInfo(c)); } });
+        }
         if self.running {
             self.tick_node(now);
             self.tick_watch(now);
@@ -2977,7 +3273,9 @@ impl Engine {
                 node_synced: st.node.synced && st.clock.severity != "block",
                 boundary_eta_s: if st.node.daa > 0 && st.program.boundary_daa > 0 { Some(st.program.eta_s) } else { None },
                 // a remote job in progress counts as busy: no update applies under it (src/jobrun.rs)
-                miner_busy: self.miners.iter().any(|m| m.building) || st.mining.cards.iter().any(|c| c.enabled && c.state == "starting") || self.jobs.active(),
+                miner_busy: self.miners.iter().any(|m| m.building) || st.mining.cards.iter().any(|c| c.enabled && c.state == "starting"),
+                // a remote job in progress holds the update, urgent or not (src/manifest.rs safe_to_apply; PC 1, 6 October 2026)
+                job_active: self.jobs.active(),
                 daa: st.node.daa,
             }
         };
@@ -2989,6 +3287,10 @@ impl Engine {
                 self.apply_update();
             }
         }
+        if let Some(ui) = self.ota.take_ui_change() {
+            self.uiota.consider(&self.shared, ui.as_ref(), VERSION);
+        }
+        self.uiota.tick(&self.shared, Instant::now());
         if let Some(p) = self.ota.take_override_change() {
             self.shared.log(&format!("consensus override changed ({}); the node restarts with it at a safe moment", p.display()));
             self.node_override_restart = true;
@@ -3155,12 +3457,24 @@ impl Engine {
     }
 
     fn tick_node(&mut self, now: Instant) {
-        if self.node_external {
-            if !port_open(self.shared.runtime.rpc_port) && now.duration_since(self.last_sync_check) >= Duration::from_secs(5) {
+        if self.node_external || self.node_refused {
+            // re-decided every 5 s: the other node leaving hands the ports to this app after the wait (7 October 2026)
+            if now.duration_since(self.last_sync_check) >= Duration::from_secs(5) {
                 self.last_sync_check = now;
-                let mut st = self.st();
-                st.node.state = "stopped".into();
-                st.node.message = "the external node went away".into();
+                let port = self.shared.runtime.rpc_port;
+                let first = self.external_gone_since.is_none();
+                match crate::extnode::step(port_open(port), self.secs(now), &mut self.external_gone_since) {
+                    crate::extnode::Step::Stay => {}
+                    crate::extnode::Step::Gone { for_s } => {
+                        let left = (crate::extnode::TAKEOVER_WAIT_S - for_s).max(0.0) as u64;
+                        if first && self.node_external { self.shared.event("info", &format!("The other node on port {port} went away; if it stays away, this app starts its own node in {left} s")); }
+                        let mut st = self.st();
+                        st.node.state = "stopped".into();
+                        st.node.synced = false;
+                        st.node.message = format!("the other node on port {port} went away; this app starts its own node in {left} s unless it comes back");
+                    }
+                    crate::extnode::Step::TakeOver => self.take_over_ports(),
+                }
             }
             return;
         }
@@ -3306,6 +3620,30 @@ impl Engine {
                     } else if verdict != crate::watchdog::Action::None {
                         // exit 43: the miner gave up on its worker; once more, then the card is faulted
                         self.watchdog_verdict(i, verdict, &tail);
+                    } else if is_stall_exit(code, &tail) {
+                        // N4: the miner found no new template for its stall span and stopped hashing and voting. Once:
+                        // the miner restarts and the node gets another look. Twice since the node started: the node
+                        // itself restarts and re-dials its peers (the seed list), because the miner alone cannot fix a
+                        // node that fell off the network.
+                        let n = { let mut st = self.st(); st.node.stall_exits += 1; st.node.stall_exits };
+                        let label = self.miners[i].label.clone();
+                        for l in &tail {
+                            self.shared.log(&format!("  miner: {l}"));
+                        }
+                        if n >= 2 {
+                            self.shared.event("error", &format!("{label}: no new block to work on, twice; the node restarts and re-dials its peers"));
+                            self.st().node.stall_exits = 0;
+                            self.restart_node("the miner saw no new block twice", Duration::from_secs(2));
+                        } else {
+                            let delay = jitter_secs(crate::platform::unix_now() + i as u64);
+                            self.miners[i].restart_at = Some(now + Duration::from_secs(delay));
+                            self.shared.event("error", &format!("{label}: no new block to work on for the stall span; the miner restarts in {delay} s (a second stall restarts the node)"));
+                            if let Some(c) = self.st().mining.cards.get_mut(card_idx) {
+                                c.state = "restarting".into();
+                                c.hash_now = 0.0;
+                                c.message = "no new block to work on; waiting for the node".into();
+                            }
+                        }
                     } else {
                         self.miners[i].restarts += 1;
                         let delay = jitter_secs(crate::platform::unix_now() + i as u64);
@@ -3540,11 +3878,17 @@ impl Engine {
     /// igneumd's own lines. One matters for the user: relayed blocks refused as "too far into the future", which is
     /// this machine's clock running behind the network (PC 2, 4 October 2026: 60 s slow after a power cut, 0 blocks).
     fn node_line(&mut self, text: &str) {
+        // miner-ui-5: every block the node validates, ours and relayed, by nonce; the miner's ACCEPTED line claims ours
+        if let Some((hash, daa, nonce)) = crate::ladder::parse_node_accepted(text) {
+            self.shared.ladder.lock().unwrap().on_node_accepted(&hash, daa, &nonce);
+            return;
+        }
         if let Some(d) = digest_from_line(text) {
             let mut st = self.st();
             if st.node.consensus_digest != d {
                 st.node.consensus_digest = d;
             }
+            if st.node.digest_source.is_empty() { st.node.digest_source = "log".into(); }
             return;
         }
         if !text.contains("too far into the future") {
@@ -3650,6 +3994,8 @@ impl Engine {
         let blue = kv_u64(text, "blue").unwrap_or(0);
         let difficulty = kv_f64(text, "difficulty").unwrap_or(0.0);
         let flag = kv(text, "synced").map(|s| s == "true");
+        // N4: the sink header's age from the node (ca3-v4-0316 appends tip_age_s after synced=); -1 on an older node
+        let tip_age_s = kv(text, "tip_age_s").and_then(|s| s.parse::<f64>().ok()).unwrap_or(-1.0);
         let was_synced = self.st().node.synced;
         // Derived from every reading, never a one-shot transition (PC 2, 4 October 2026: the node caught up after a
         // clock fix and mined at 118 MH/s while the card still said "syncing", because getInfo's flag stayed false).
@@ -3662,7 +4008,24 @@ impl Engine {
         let stable_s = self.sync_stable_since.map(|t| now.duration_since(t).as_secs_f64()).unwrap_or(0.0);
         let accepted_recent = self.last_accepted.map(|t| now.duration_since(t) <= Duration::from_secs(60)).unwrap_or(false);
         let private = self.shared.runtime.unsynced_mining && self.shared.runtime.peers.is_empty();
-        let synced = sync_decision(&Reading { blocks, headers, peers, flag }, caught_up_moving, stable_s, accepted_recent, private);
+        let (mut synced, mut cause) = sync_decision_v2(&Reading { blocks, headers, peers, flag }, caught_up_moving, stable_s, accepted_recent, private, tip_age_s);
+        // 0.3.18: a synced-looking node whose blocks never merge into the network reads "behind" and holds the miner
+        if synced && !private {
+            let since = *self.merge_mining_since.get_or_insert(now);
+            let check = crate::merge::MergeCheck {
+                our_blue: blue,
+                peer_sinks: self.merge_sinks.clone(),
+                merge_depth: self.merge_depth,
+                ours_seen_ago_s: self.merge_ours_seen.map(|t| now.duration_since(t).as_secs_f64()),
+                mining_for_s: now.duration_since(since).as_secs_f64(),
+            };
+            if crate::merge::not_merging(&check) {
+                synced = false;
+                cause = "not merging";
+            }
+        } else if !synced {
+            self.merge_mining_since = None;
+        }
         self.sync_prev = Some(blocks);
         // the first clock source: local time against the latest block the peers produced, once blocks arrive
         if blocks > 0 && (peers > 0 || self.shared.runtime.peers.is_empty()) && now.duration_since(self.clock_last_sample) >= Duration::from_secs(9) {
@@ -3685,20 +4048,41 @@ impl Engine {
             st.node.blue = blue;
             st.node.difficulty = difficulty;
             st.node.synced = synced;
-            st.node.state = if synced { "synced".into() } else { "syncing".into() };
+            st.node.tip_age_s = tip_age_s;
+            st.node.sync_cause = cause.to_string();
+            // the state word: "behind" for a frozen tip, "no peers" for none, "syncing" for the rest (N4: never
+            // "synced" on a tip that stopped moving)
+            st.node.state = if synced { "synced".into() } else if cause == "frozen" || cause == "not merging" { "behind".into() } else if cause == "no peers" { "no peers".into() } else { "syncing".into() };
             st.node.message = if synced {
                 String::new()
+            } else if cause == "not merging" {
+                crate::merge::NOT_MERGING.to_string()
+            } else if cause == "frozen" {
+                format!("no new block for {} s with {peers} peer{}; the chain may have moved on without this node", tip_age_s.round() as i64, if peers == 1 { "" } else { "s" })
             } else if peers == 0 {
-                "waiting for a peer".into()
+                "waiting for a peer on our chain".into()
             } else if headers > blocks + 2 {
                 format!("{blocks} of {headers} blocks")
             } else {
                 "caught up, waiting for the next block".into()
             };
         }
+        if !synced && was_synced && cause == "not merging" {
+            self.shared.event("error", &format!("{}; the network's sink is {} blocks past ours, so the miner is held until this node merges again", crate::merge::NOT_MERGING, self.merge_sinks.iter().max().copied().unwrap_or(0).saturating_sub(blue)));
+        }
         if synced && !was_synced {
             self.shared.event("ok", &format!("node synced: {blocks} blocks, {peers} peer(s)"));
+            // miner-ui-5: the first-hour timeline's "node synced" mark, once per install
+            if self.shared.ladder.lock().unwrap().mark("synced", crate::platform::unix_now_f()) { self.shared.save_ladder(); }
+            let t = self.secs(now);
+            let names: Vec<String> = self.st().mining.cards.iter().map(|c| c.name.clone()).collect();
             for m in self.miners.iter_mut() {
+                // a card faulted for silence while the node was not ready starts again now (PC 1, 7 October 2026)
+                if m.watch.faulted_by_node() {
+                    m.watch.event(t, crate::watchdog::Event::NodeSynced);
+                    let name = names.get(m.card).cloned().unwrap_or_else(|| m.label.clone());
+                    self.shared.event("info", &format!("{name}: starts again now the node is synced (it was faulted for silence while the node was syncing)"));
+                }
                 if m.proc.is_none() && m.restart_at.is_none() && m.watch.faulted().is_none() {
                     m.restart_at = Some(now);
                 }
@@ -3714,6 +4098,22 @@ impl Engine {
         let Some(i) = self.miners.iter().position(|m| m.card == card) else { return };
         let label = self.miners[i].label.clone();
         let card_name = self.st().mining.cards.get(card).map(|c| c.name.clone()).unwrap_or_else(|| label.clone());
+        if text.contains("template fetch timed out") {
+            // PC 1, 7 October 2026 04:51Z: the node reported synced while its finality replay blocked the template
+            // RPC for three minutes; the miner printed only these lines, and the watchdog faulted every card for
+            // silence. The line is the miner's heartbeat: the card waits on the node, with one Activity line per episode
+            let now = Instant::now();
+            let t = self.secs(now);
+            let first = !self.miners[i].watch.templates_blocked();
+            self.miners[i].watch.event(t, crate::watchdog::Event::TemplateTimeout);
+            if first {
+                self.shared.event("info", &format!("{card_name}: the node is not answering block templates yet; the miner keeps asking (the node catches up after a restart)"));
+            }
+            if let Some(c) = self.st().mining.cards.get_mut(card) {
+                c.message = "waiting for the node to answer block templates".into();
+            }
+            return;
+        }
         if stderr {
             if text.contains(" rejected nonce=") {
                 if let Some(run) = self.sweep.as_mut() {
@@ -3799,8 +4199,16 @@ impl Engine {
             if let Some(c) = st.mining.cards.get_mut(card) {
                 c.accepted += 1;
             }
+            let card_key = st.mining.cards.get(card).map(|c| c.key.clone()).unwrap_or_default();
             drop(st);
             self.shared.event("block", &format!("block accepted by the node ({card_name})"));
+            // miner-ui-5: the machine's own ladder record (the block card, the days ring); the hash joins by nonce
+            let nonce = crate::ladder::parse_miner_accepted(text).unwrap_or_default();
+            let milestone = self.shared.ladder.lock().unwrap().on_block(unix, &card_key, &card_name, &nonce, total);
+            self.shared.save_ladder();
+            if let Some(m) = milestone {
+                self.shared.event("block", &crate::ladder::milestone_event(&m));
+            }
         } else if let Some(s) = crate::watchdog::parse_status(text) {
             let now = Instant::now();
             self.miners[i].last_status = Some(now);
@@ -3839,6 +4247,8 @@ impl Engine {
                     c.message = if s.mismatched > 0 { format!("{} share(s) failed the CPU re-check this run", s.mismatched) } else { String::new() };
                 }
             }
+            // miner-ui-5: the first-hour timeline's "card mining" mark, once per install, on the first status with a rate
+            if s.hash_now > 0.0 && self.shared.ladder.lock().unwrap().mark("mining", crate::platform::unix_now_f()) { self.shared.save_ladder(); }
         } else if text.contains(" worker: race ") {
             self.race_line(card, &card_name, text);
         } else if text.contains(" worker: ready ") {
@@ -3900,9 +4310,16 @@ impl Engine {
                     st.finality.last_lock_at = crate::platform::unix_now_f();
                     st.finality.age_s = 0.0;
                 }
+                drop(st);
+                // miner-ui-5: every checkpoint this machine signed at or under the lock is in a certificate now
+                self.shared.ladder.lock().unwrap().on_lock(n);
+                self.shared.save_ladder();
             }
         } else if text.contains(" VOTE index=") {
             self.st().finality.votes += 1;
+            if let Some(idx) = crate::ladder::parse_vote_index(text) {
+                self.shared.ladder.lock().unwrap().on_vote(crate::platform::unix_now_f(), idx, LADDER_GAP_S);
+            }
         } else if text.contains("worker could not prepare") || text.contains(" prepare-failed ") {
             self.st().program.prepared = false;
             self.shared.event("error", &format!("{card_name}: the worker could not compile the next program; it compiles at the boundary"));
@@ -4227,6 +4644,38 @@ pub fn sync_decision(r: &Reading, moving: bool, stable_s: f64, accepted_recent:
     caught_up && (moving || stable_s >= 60.0)
 }
 
+/// The tip age at which a node that still says "synced" is treated as frozen (ledger N4, 6 October 2026: a home
+/// miner's one same-digest peer relayed nothing for 53 minutes while the app read "mining, synced").
+pub const TIP_FROZEN_S: f64 = 120.0;
+
+/// N4: what "synced" means on every surface. The old decision, AND the tip moved in the last 120 s (the watch
+/// line's tip_age_s, the sink header's age; -1 = the node does not report it yet, which gates nothing so an older node
+/// keeps today's words), AND at least one peer (the handshake refuses a peer with another digest, so `peers` already
+/// counts peers on our chain). Returns (synced, cause): the cause is "" when synced, else "frozen" (a peer, caught up,
+/// no new block for over 120 s), "no peers", "syncing", or "behind" (the node's own flag false while the count moves).
+pub fn sync_decision_v2(r: &Reading, moving: bool, stable_s: f64, accepted_recent: bool, private: bool, tip_age_s: f64) -> (bool, &'static str) {
+    if private {
+        return (true, "");
+    }
+    let frozen = tip_age_s > TIP_FROZEN_S && !accepted_recent;
+    if r.peers == 0 && !accepted_recent {
+        return (false, "no peers");
+    }
+    if frozen {
+        return (false, "frozen");
+    }
+    if sync_decision(r, moving, stable_s, accepted_recent, private) {
+        return (true, "");
+    }
+    (false, if r.headers > r.blocks + 2 { "syncing" } else { "behind" })
+}
+
+/// The miner's stall exit (the node lane, ca3-v4-0316): code 45, or a tail line starting "STALLED '".
+pub const STALL_EXIT_CODE: i32 = 45;
+pub fn is_stall_exit(code: i32, tail: &[String]) -> bool {
+    code == STALL_EXIT_CODE || tail.iter().any(|l| l.contains(" STALLED '") || l.starts_with("STALLED '"))
+}
+
 /// "...block timestamp is 1791112663000 but maximum timestamp allowed is 1791112600000" -> at least 63 s behind.
 fn behind_from_warning(text: &str) -> Option<f64> {
     let nums: Vec<f64> = text.split(|c: char| !c.is_ascii_digit()).filter(|s| s.len() >= 12).filter_map(|s| s.parse::<f64>().ok()).collect();
@@ -4385,7 +4834,7 @@ mod tests {
         assert_eq!(super::power_control_after_prompt(&Err("the elevated step exited with code 2".into())), None);
     }
 
-    use super::{digest_from_line, parse_race, switches_of, sync_decision, Reading};
+    use super::{is_stall_exit, sync_decision_v2, digest_from_line, parse_race, switches_of, sync_decision, Reading};
 
     #[test]
     fn digest_comes_from_the_nodes_own_line_only() {
@@ -4457,6 +4906,44 @@ mod tests {
         assert!(sync_decision(&r(0, 0, 0, None), false, 0.0, false, true));
     }
 
+    /// Ledger N4 (6 October 2026): a home miner's node kept one same-digest peer that relayed nothing for 53 minutes;
+    /// today's rule said "synced" the whole time. The known-failed case first, then the fix.
+    #[test]
+    fn n4_a_frozen_tip_is_never_synced() {
+        // the frozen tip: caught up, one peer, the count stable for an hour, getInfo's flag true. Today: synced.
+        let frozen = r(133_000, 133_000, 1, Some(true));
+        assert!(sync_decision(&frozen, false, 3_180.0, false, false), "the old rule says synced on the frozen tip (the N4 failure)");
+        // the fix: the tip age gates it
+        let (ok, cause) = sync_decision_v2(&frozen, false, 3_180.0, false, false, 3_180.0);
+        assert!(!ok);
+        assert_eq!(cause, "frozen");
+        // the same node moving: synced
+        assert_eq!(sync_decision_v2(&frozen, true, 0.0, false, false, 4.0), (true, ""));
+        // exactly at the bound is still synced; one second over is not
+        assert_eq!(sync_decision_v2(&frozen, false, 60.0, false, false, 120.0), (true, ""));
+        assert_eq!(sync_decision_v2(&frozen, false, 60.0, false, false, 121.0), (false, "frozen"));
+        // an older node that does not report the age (-1) keeps today's words
+        assert_eq!(sync_decision_v2(&frozen, false, 60.0, false, false, -1.0), (true, ""));
+        // our own block accepted in the last minute proves the tip moves, whatever the reported age
+        assert_eq!(sync_decision_v2(&frozen, false, 60.0, true, false, 900.0), (true, ""));
+        // no peer at all: "no peers", not "frozen" and never synced
+        assert_eq!(sync_decision_v2(&r(133_000, 133_000, 0, Some(true)), false, 600.0, false, false, 500.0), (false, "no peers"));
+        // still downloading: "syncing"
+        assert_eq!(sync_decision_v2(&r(100, 700, 1, Some(false)), true, 0.0, false, false, 2.0), (false, "syncing"));
+        // caught up but the flag false and the count not yet stable: "behind"
+        assert_eq!(sync_decision_v2(&r(700, 700, 1, Some(false)), false, 10.0, false, false, 5.0), (false, "behind"));
+        // a private test node is always synced
+        assert_eq!(sync_decision_v2(&r(0, 0, 0, None), false, 0.0, false, true, 9_999.0), (true, ""));
+    }
+
+    #[test]
+    fn n4_the_stall_exit_is_code_45_or_the_stalled_line() {
+        assert!(is_stall_exit(45, &[]));
+        assert!(is_stall_exit(1, &["1791327000.123 STALLED 'nvidia-1ccfe586-1': no new template for 300 s (tip d3dc2f78, daa 197752); the node has fallen off the network or stopped moving; hashing and voting paused, exiting with code 45 so the launcher restarts (and after a second stall, restarts the node)".to_string()]));
+        assert!(!is_stall_exit(1, &["worker fault: rejected nonce".to_string()]));
+        assert!(!is_stall_exit(42, &[]));
+    }
+
     #[test]
     fn node_warning() {
         let l = "2026-10-04 11:02:11.123+00:00 [WARN ] HandleRelayInvsFlow flow error: the block timestamp is too far into the future: block timestamp is 1791112663000 but maximum timestamp allowed is 1791112600000";

app/igneum-app/src/extnode.rs

@@ -0,0 +1,249 @@
+//! Another node on this machine (publish 2's read-back, 6 October 2026): the hand node on the Mac held 26610/26611,
+//! the app's default RPC and p2p ports, the app read its state as its own and the digest field read empty. Now the
+//! collision is loud on every surface and checked: the other node's chain id (eth_chainId on the EVM port) and its
+//! consensus overrides (`igneum_getNodeInfo`, the node lane, 7 October 2026; "method not found" on an older node) against the
+//! override file the app would start its own node with. A match: "Another node holds port N on this machine; using
+//! it". A mismatch: "Node not started: port N is taken" and the app does not read that node. Unknown (an older node
+//! that cannot answer): used, and said so. The same RPC gives the digest, so api/state carries it for an external node
+//! too, read every 30 s instead of parsed from a stdout the app does not own.
+use serde_json::{json, Value};
+use std::path::Path;
+use std::process::Command;
+use std::time::Duration;
+
+/// What the other node answered: None where it could not answer.
+#[derive(Debug, Default, Clone)]
+pub struct Check {
+    pub chain_id: Option<u64>,
+    pub digest: Option<String>,
+    pub network: Option<String>,
+    pub version: Option<String>,
+    /// the node's consensus params as it resolved them (`params` in igneum_getNodeInfo, every field by its override-file name)
+    pub overrides: Option<Value>,
+    /// "igneum-pow" or "stub" (ledger N5: a node built without the mining engine refuses every real block)
+    pub pow_engine: Option<String>,
+    /// the network's compiled merge depth in blue score (`blockrate.mergeDepth`, the node lane's 0.3.18 addition);
+    /// None on a node without the object, and the app assumes 3,600 (1 bps)
+    pub merge_depth: Option<u64>,
+}
+
+/// The decision for the port-collision path.
+#[derive(Debug, PartialEq)]
+pub struct Decision {
+    pub use_it: bool,
+    /// match | mismatch | unknown
+    pub verdict: &'static str,
+    /// the event line, in a user's words
+    pub line: String,
+}
+
+/// Compare the other node with ours: `ours` is the override file the app would start its own node with (the
+/// `*_activation_daa` and friends), `our_chain` the chain id this app's network uses when known.
+pub fn decide(port: u16, ours: Option<&Value>, our_chain: Option<u64>, theirs: &Check) -> Decision { decide_on(port, ours, our_chain, None, theirs) }
+
+/// `decide` with the network name too (devnet | simnet | testnet): the node lane's rule is that `network` must be equal.
+pub fn decide_on(port: u16, ours: Option<&Value>, our_chain: Option<u64>, our_network: Option<&str>, theirs: &Check) -> Decision {
+    let mut checked = false;
+    if let (Some(a), Some(b)) = (our_network.filter(|s| !s.is_empty()), theirs.network.as_deref().filter(|s| !s.is_empty())) {
+        checked = true;
+        if a != b {
+            return Decision { use_it: false, verdict: "mismatch", line: format!("Node not started: port {port} is taken by a node on another network ({b}, ours {a})") };
+        }
+    }
+    if let (Some(a), Some(b)) = (our_chain, theirs.chain_id) {
+        checked = true;
+        if a != b {
+            return Decision { use_it: false, verdict: "mismatch", line: format!("Node not started: port {port} is taken by a node on another network (chain id {b}, ours {a})") };
+        }
+    }
+    if theirs.pow_engine.as_deref() == Some("stub") {
+        return Decision { use_it: false, verdict: "mismatch", line: format!("Node not started: port {port} is taken by a node built without the mining engine (stub), which refuses every real block") };
+    }
+    // every key the manifest sets, against the node's resolved params (the node lane: compare values, never recompute the hash)
+    if let (Some(o), Some(t)) = (ours.and_then(|v| v.as_object()), theirs.overrides.as_ref().and_then(|v| v.as_object())) {
+        checked = true;
+        for (k, v) in o {
+            if t.get(k) != Some(v) {
+                let theirs_v = t.get(k).map(|x| x.to_string()).unwrap_or_else(|| "none".into());
+                return Decision { use_it: false, verdict: "mismatch", line: format!("Node not started: port {port} is taken by a node on other rules ({k} {theirs_v}, ours {v})") };
+            }
+        }
+    }
+    if checked {
+        Decision { use_it: true, verdict: "match", line: format!("Another node holds port {port} on this machine; using it (same network and rules; it is not stopped by this app)") }
+    } else {
+        Decision { use_it: true, verdict: "unknown", line: format!("Another node holds port {port} on this machine; using it. Its rules could not be checked (an older node that lacks igneum_getNodeInfo), so the app reads it as it is") }
+    }
+}
+
+/// How long the app waits after another node leaves its ports before starting its own (the Mac, 7 October 2026: the
+/// hand node left at 00:18 UK and the app sat on "node stopped" all night, since the mode was decided once at launch).
+pub const TAKEOVER_WAIT_S: f64 = 60.0;
+
+/// What the app does about ports another node held, re-checked while attached (external) or refused (none).
+#[derive(Debug, PartialEq)]
+pub enum Step {
+    /// the other node still answers on the port
+    Stay,
+    /// the port has been closed for `for_s` seconds; the app waits out TAKEOVER_WAIT_S in case it comes back
+    Gone { for_s: f64 },
+    /// the port stayed closed for TAKEOVER_WAIT_S: start our own node on the freed ports
+    TakeOver,
+}
+
+/// `port_open` is whether the other node's RPC port answers now, `gone_since` the app's memory of when it stopped
+/// answering (None while it answers). A node that comes back inside the wait is kept; the wait starts over.
+pub fn step(port_open: bool, now_s: f64, gone_since: &mut Option<f64>) -> Step {
+    if port_open {
+        *gone_since = None;
+        return Step::Stay;
+    }
+    let since = *gone_since.get_or_insert(now_s);
+    let for_s = now_s - since;
+    if for_s >= TAKEOVER_WAIT_S {
+        *gone_since = None;
+        Step::TakeOver
+    } else {
+        Step::Gone { for_s }
+    }
+}
+
+/// One JSON-RPC call to the node's EVM port through curl (the engine carries no HTTP client; update.rs does the same).
+pub fn rpc(evm_port: u16, method: &str, params: Value, limit: Duration) -> Option<Value> {
+    let body = json!({ "jsonrpc": "2.0", "id": 1, "method": method, "params": params }).to_string();
+    let out = crate::detect::run_timeout(
+        Command::new(crate::platform::tool("curl")).args(["-s", "--max-time", &format!("{}", limit.as_secs().max(1)), "-X", "POST", &format!("http://127.0.0.1:{evm_port}"), "-H", "Content-Type: application/json", "-d", &body]),
+        None,
+        limit + Duration::from_secs(2),
+    )?;
+    let v: Value = serde_json::from_str(&out).ok()?;
+    v.get("result").cloned().filter(|r| !r.is_null())
+}
+
+/// The other node's answers, with what each method gives: eth_chainId (every node), igneum_getNodeInfo (newer nodes).
+pub fn probe(evm_port: u16) -> Check {
+    let mut c = Check::default();
+    if let Some(Value::String(h)) = rpc(evm_port, "eth_chainId", json!([]), Duration::from_secs(4)) {
+        c.chain_id = u64::from_str_radix(h.trim_start_matches("0x"), 16).ok();
+    }
+    if let Some(info) = rpc(evm_port, "igneum_getNodeInfo", json!([]), Duration::from_secs(4)) {
+        c.digest = info.get("digest").and_then(|v| v.as_str()).map(|s| s.to_string());
+        c.network = info.get("network").and_then(|v| v.as_str()).map(|s| s.to_string());
+        c.version = info.get("version").and_then(|v| v.as_str()).map(|s| s.to_string());
+        c.overrides = info.get("params").cloned().filter(|v| v.is_object());
+        c.pow_engine = info.get("powEngine").and_then(|v| v.as_str()).map(|s| s.to_string());
+        c.merge_depth = info.get("blockrate").and_then(|b| b.get("mergeDepth")).and_then(|v| v.as_u64());
+    }
+    c
+}
+
+/// Keep the newest `keep` files named `<prefix>...` in `dir`; the rest go (the node and miner logs grow one per start).
+pub fn prune_logs(dir: &Path, prefix: &str, keep: usize) -> usize {
+    let Ok(rd) = std::fs::read_dir(dir) else { return 0 };
+    let mut files: Vec<(std::time::SystemTime, std::path::PathBuf)> = rd
+        .flatten()
+        .filter(|e| e.file_name().to_string_lossy().starts_with(prefix) && e.path().extension().map(|x| x == "log").unwrap_or(false))
+        .filter_map(|e| e.metadata().ok().and_then(|m| m.modified().ok()).map(|t| (t, e.path())))
+        .collect();
+    files.sort_by(|a, b| b.0.cmp(&a.0));
+    let mut removed = 0;
+    for (_, p) in files.into_iter().skip(keep) {
+        if std::fs::remove_file(&p).is_ok() {
+            removed += 1;
+        }
+    }
+    removed
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ours() -> Value { json!({ "difficulty_v2_activation_daa": 33000, "fees_v1_activation_daa": 210000, "exec_restart_number": 27276, "exec_restart_hash": "bb45cf0d" }) }
+
+    /// The Mac, 6 October 2026: the hand node held the ports; the app said nothing and read it as its own.
+    #[test]
+    fn a_node_on_our_rules_is_used_and_said_so() {
+        let theirs = Check { chain_id: Some(7_777), overrides: Some(ours()), digest: Some("1f4b".into()), ..Default::default() };
+        let d = decide(26611, Some(&ours()), Some(7_777), &theirs);
+        assert!(d.use_it);
+        assert_eq!(d.verdict, "match");
+        assert_eq!(d.line, "Another node holds port 26611 on this machine; using it (same network and rules; it is not stopped by this app)");
+    }
+
+    #[test]
+    fn a_node_on_another_network_or_other_rules_is_refused() {
+        let other_chain = Check { chain_id: Some(7_778), ..Default::default() };
+        let d = decide(26611, Some(&ours()), Some(7_777), &other_chain);
+        assert!(!d.use_it);
+        assert_eq!(d.verdict, "mismatch");
+        assert_eq!(d.line, "Node not started: port 26611 is taken by a node on another network (chain id 7778, ours 7777)");
+        let mut theirs = ours(); theirs["fees_v1_activation_daa"] = json!(200000);
+        let d = decide(26611, Some(&ours()), None, &Check { overrides: Some(theirs), ..Default::default() });
+        assert!(!d.use_it);
+        assert_eq!(d.line, "Node not started: port 26611 is taken by a node on other rules (fees_v1_activation_daa 200000, ours 210000)");
+        // the merge depth comes from blockrate.mergeDepth (compiled per network), never from params
+        assert_eq!(Check { merge_depth: Some(36_000), ..Default::default() }.merge_depth, Some(36_000));
+        // a stub engine is refused whatever else matches
+        assert!(!decide(26611, Some(&ours()), None, &Check { overrides: Some(ours()), pow_engine: Some("stub".into()), ..Default::default() }).use_it);
+        // an override we have that the other node lacks is a mismatch too
+        let d = decide(26611, Some(&ours()), None, &Check { overrides: Some(json!({ "difficulty_v2_activation_daa": 33000 })), ..Default::default() });
+        assert!(!d.use_it);
+        assert!(d.line.contains("exec_restart_hash none"), "{}", d.line);
+        // the network name (node lane, igneum_getNodeInfo.network) must be equal
+        let d = decide_on(26611, Some(&ours()), None, Some("testnet"), &Check { network: Some("devnet".into()), overrides: Some(ours()), ..Default::default() });
+        assert!(!d.use_it);
+        assert_eq!(d.line, "Node not started: port 26611 is taken by a node on another network (devnet, ours testnet)");
+        assert!(decide_on(26611, Some(&ours()), None, Some("testnet"), &Check { network: Some("testnet".into()), overrides: Some(ours()), ..Default::default() }).use_it);
+    }
+
+    #[test]
+    fn an_older_node_that_cannot_answer_is_used_and_marked_unknown() {
+        let d = decide(26611, Some(&ours()), None, &Check::default());
+        assert!(d.use_it);
+        assert_eq!(d.verdict, "unknown");
+        assert!(d.line.starts_with("Another node holds port 26611 on this machine; using it. Its rules could not be checked"));
+        // a chain id alone, matching, is a check
+        assert_eq!(decide(26611, None, Some(1), &Check { chain_id: Some(1), ..Default::default() }).verdict, "match");
+    }
+
+    /// The Mac, 7 October 2026 00:18 UK: the hand node left and the app never started its own (today's app never recovers).
+    #[test]
+    fn an_external_node_that_goes_away_hands_the_ports_to_the_app_after_the_wait() {
+        let mut gone = None;
+        assert_eq!(step(true, 0.0, &mut gone), Step::Stay);
+        assert_eq!(gone, None);
+        assert_eq!(step(false, 100.0, &mut gone), Step::Gone { for_s: 0.0 });
+        assert_eq!(step(false, 130.0, &mut gone), Step::Gone { for_s: 30.0 });
+        assert_eq!(step(false, 160.0, &mut gone), Step::TakeOver);
+        assert_eq!(gone, None, "the memory resets once the app has its own node");
+        // a node that comes back inside the wait is kept, and the wait starts over
+        let mut gone = None;
+        assert_eq!(step(false, 0.0, &mut gone), Step::Gone { for_s: 0.0 });
+        assert_eq!(step(true, 30.0, &mut gone), Step::Stay);
+        assert_eq!(step(false, 40.0, &mut gone), Step::Gone { for_s: 0.0 });
+        assert_eq!(step(false, 99.0, &mut gone), Step::Gone { for_s: 59.0 });
+        assert_eq!(step(false, 100.0, &mut gone), Step::TakeOver);
+    }
+
+    #[test]
+    fn prune_keeps_the_newest_logs() {
+        let dir = std::env::temp_dir().join(format!("igneum-prune-test-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        for i in 0..6 {
+            let p = dir.join(format!("node-2026100{i}.log"));
+            std::fs::write(&p, "x").unwrap();
+            let t = std::time::SystemTime::UNIX_EPOCH + Duration::from_secs(1_700_000_000 + i * 60);
+            let f = std::fs::File::options().write(true).open(&p).unwrap();
+            f.set_modified(t).unwrap();
+        }
+        std::fs::write(dir.join("miner-1.log"), "y").unwrap();
+        std::fs::write(dir.join("node-notes.txt"), "z").unwrap();
+        assert_eq!(prune_logs(&dir, "node-", 4), 2);
+        let mut left: Vec<String> = std::fs::read_dir(&dir).unwrap().flatten().map(|e| e.file_name().to_string_lossy().into_owned()).collect();
+        left.sort();
+        assert_eq!(left, vec!["miner-1.log", "node-20261002.log", "node-20261003.log", "node-20261004.log", "node-20261005.log", "node-notes.txt"]);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}

app/igneum-app/src/hotplug.rs

@@ -167,6 +167,9 @@ pub fn apply_pref(c: &mut CardState, p: &CardPref) {
     c.mem_cap_mhz = if p.pinned || p.sweep_source == "baseline" { 0 } else { p.sweep_mem_mhz };
     c.clock_cap_mhz = if p.pinned || p.sweep_source == "baseline" { 0 } else { p.sweep_clock_mhz };
     c.tune_source = p.sweep_source.clone();
+    c.tune_goal = p.tune_goal.clone();
+    c.tune_before_watts = p.sweep_before_watts;
+    c.tune_before_mhs = p.sweep_before_mhs;
     if p.sweep_mhs > 0.0 && p.sweep_watts > 0.0 {
         c.tune_line = crate::ember::tuned_line(p.sweep_mhs, p.sweep_watts, p.sweep_eff);
     }

app/igneum-app/src/ladder.rs

@@ -0,0 +1,514 @@
+//! The miner's first month, as this machine records it (miner-ui-5, mission item 6, 7 October 2026). The ladder's
+//! rungs are chain facts (src/chainfacts.rs reads them from `getFinalityWeights` and `getFinalityCheckpoints`); this
+//! module keeps what only this machine knows: when its first block came and on which card, the blocks it found per day
+//! (the days-mined ring), every checkpoint its miners signed and which of those locked (the signing streak), the shards
+//! its cards were paid for, and the block card to show (the first block, every 100th, 1,000th and 10,000th, the first
+//! on a new card). Persisted as `<app dir>/ladder.json`; pure, no clock of its own (every call takes `now`).
+//!
+//! A block is matched to its hash by the nonce: the miner prints `ACCEPTED block nonce=0x..` for ours, the node prints
+//! `PoW accepted <hash> by .. (daa N, .., nonce 0x..)` for every block it validates, ours and relayed alike, so the
+//! nonce is the join and nothing else is.
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+pub const DAY_S: f64 = 86_400.0;
+/// days kept in the ring (the 30-day window plus a month of slack for the view)
+const KEEP_DAYS: u64 = 60;
+const KEEP_BLOCKS: usize = 30;
+const KEEP_SHARDS: usize = 50;
+const KEEP_PENDING: usize = 400;
+const KEEP_SIGNED: usize = 400;
+/// the block counts that raise a card (then every 10,000th)
+pub const MILESTONES: [u64; 4] = [1, 100, 1_000, 10_000];
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct DayBlocks {
+    /// unix day number (unix seconds / 86,400, UTC)
+    pub day: u64,
+    pub blocks: u64,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct BlockFound {
+    pub hash: String,
+    pub daa: u64,
+    pub nonce: String,
+    pub at: f64,
+    pub card: String,
+    pub card_name: String,
+    /// this machine's lifetime count at that block (1 = the first)
+    pub count: u64,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct ShardPaid {
+    pub block: u64,
+    pub shard: u64,
+    /// wei as a decimal string (u128 does not survive every JSON reader)
+    pub wei: String,
+    pub at: f64,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct Milestone {
+    /// first | hundred | thousand | ten_thousand | card
+    pub kind: String,
+    pub count: u64,
+    pub card: String,
+    pub card_name: String,
+    pub hash: String,
+    pub daa: u64,
+    pub at: f64,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct Ladder {
+    #[serde(default)]
+    pub first_block_at: f64,
+    #[serde(default)]
+    pub first_block_card: String,
+    #[serde(default)]
+    pub first_block_hash: String,
+    #[serde(default)]
+    pub first_block_daa: u64,
+    #[serde(default)]
+    pub days: Vec<DayBlocks>,
+    /// card key -> unix s of its first block
+    #[serde(default)]
+    pub cards_first: BTreeMap<String, f64>,
+    #[serde(default)]
+    pub blocks: Vec<BlockFound>,
+    #[serde(default)]
+    pub votes_signed: u64,
+    #[serde(default)]
+    pub last_vote_index: u64,
+    #[serde(default)]
+    pub last_vote_at: f64,
+    /// checkpoints signed and not yet seen locked
+    #[serde(default)]
+    pub signed_open: Vec<u64>,
+    #[serde(default)]
+    pub last_signed_locked: u64,
+    #[serde(default)]
+    pub signed_locked_count: u64,
+    /// when the unbroken run of votes began (0 = no vote yet)
+    #[serde(default)]
+    pub streak_since: f64,
+    #[serde(default)]
+    pub shards: Vec<ShardPaid>,
+    #[serde(default)]
+    pub milestone: Option<Milestone>,
+    /// the first-hour timeline's marks: when this install's node first synced and a card first mined (0 = not yet)
+    #[serde(default)]
+    pub first_synced_at: f64,
+    #[serde(default)]
+    pub first_mining_at: f64,
+    /// node-accepted blocks waiting for the miner's own ACCEPTED line (nonce -> hash, daa), and the reverse case
+    #[serde(default)]
+    pending: Vec<(String, String, u64)>,
+}
+
+/// What the dashboard reads (api/state.ladder): the record above summarised at `now`.
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct LadderState {
+    pub first_block_at: f64,
+    pub first_block_card: String,
+    pub first_block_hash: String,
+    pub first_block_daa: u64,
+    /// distinct UTC days with at least one block in the last 30 days
+    pub days_mined_30: u64,
+    pub blocks_30d: u64,
+    pub blocks_today: u64,
+    pub days: Vec<DayBlocks>,
+    pub cards_first: BTreeMap<String, f64>,
+    pub blocks: Vec<BlockFound>,
+    pub votes_signed: u64,
+    pub last_vote_index: u64,
+    pub last_vote_at: f64,
+    pub last_signed_locked: u64,
+    pub signed_locked_count: u64,
+    /// seconds of unbroken signing (0 = none)
+    pub streak_s: f64,
+    pub shards: Vec<ShardPaid>,
+    pub milestone: Option<Milestone>,
+    pub first_synced_at: f64,
+    pub first_mining_at: f64,
+}
+
+pub fn day_of(unix: f64) -> u64 {
+    (unix.max(0.0) / DAY_S).floor() as u64
+}
+
+impl Ladder {
+    pub fn load(path: &std::path::Path) -> Ladder {
+        std::fs::read_to_string(path).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or_default()
+    }
+    pub fn save(&self, path: &std::path::Path) {
+        if let Some(d) = path.parent() {
+            let _ = std::fs::create_dir_all(d);
+        }
+        if let Ok(t) = serde_json::to_string_pretty(self) {
+            let _ = std::fs::write(path, t);
+        }
+    }
+
+    /// The node validated a block (its own log line): remembered by nonce until the miner's line claims it.
+    pub fn on_node_accepted(&mut self, hash: &str, daa: u64, nonce: &str) {
+        let nonce = norm_nonce(nonce);
+        if nonce.is_empty() || hash.is_empty() {
+            return;
+        }
+        // a block of ours whose miner line came first: fill the hash in now
+        if let Some(b) = self.blocks.iter_mut().find(|b| b.hash.is_empty() && b.nonce == nonce) {
+            b.hash = hash.to_string();
+            b.daa = daa;
+            if self.first_block_hash.is_empty() && self.first_block_at == b.at {
+                self.first_block_hash = hash.to_string();
+                self.first_block_daa = daa;
+            }
+            if let Some(m) = self.milestone.as_mut() {
+                if m.hash.is_empty() && m.at == b.at {
+                    m.hash = hash.to_string();
+                    m.daa = daa;
+                }
+            }
+            return;
+        }
+        self.pending.push((nonce, hash.to_string(), daa));
+        if self.pending.len() > KEEP_PENDING {
+            let n = self.pending.len() - KEEP_PENDING;
+            self.pending.drain(0..n);
+        }
+    }
+
+    /// The miner's own ACCEPTED line: `total` is this machine's lifetime count including this block. Returns the
+    /// milestone this block raised, if any.
+    pub fn on_block(&mut self, now: f64, card: &str, card_name: &str, nonce: &str, total: u64) -> Option<Milestone> {
+        let nonce = norm_nonce(nonce);
+        let (hash, daa) = match self.pending.iter().position(|p| !nonce.is_empty() && p.0 == nonce) {
+            Some(i) => {
+                let p = self.pending.remove(i);
+                (p.1, p.2)
+            }
+            None => (String::new(), 0),
+        };
+        let day = day_of(now);
+        match self.days.iter_mut().find(|d| d.day == day) {
+            Some(d) => d.blocks += 1,
+            None => self.days.push(DayBlocks { day, blocks: 1 }),
+        }
+        self.days.sort_by_key(|d| d.day);
+        if self.days.len() > KEEP_DAYS as usize {
+            let n = self.days.len() - KEEP_DAYS as usize;
+            self.days.drain(0..n);
+        }
+        if self.first_block_at == 0.0 {
+            self.first_block_at = now;
+            self.first_block_card = card.to_string();
+            self.first_block_hash = hash.clone();
+            self.first_block_daa = daa;
+        }
+        let new_card = !card.is_empty() && !self.cards_first.contains_key(card);
+        if new_card {
+            self.cards_first.insert(card.to_string(), now);
+        }
+        self.blocks.insert(0, BlockFound { hash: hash.clone(), daa, nonce, at: now, card: card.to_string(), card_name: card_name.to_string(), count: total });
+        self.blocks.truncate(KEEP_BLOCKS);
+        let kind = if total == 1 { "first" } else if total == 100 { "hundred" } else if total == 1_000 { "thousand" } else if total >= 10_000 && total % 10_000 == 0 { "ten_thousand" } else if new_card { "card" } else { "" };
+        if kind.is_empty() {
+            return None;
+        }
+        let m = Milestone { kind: kind.into(), count: total, card: card.into(), card_name: card_name.into(), hash, daa, at: now };
+        self.milestone = Some(m.clone());
+        Some(m)
+    }
+
+    /// A `VOTE index=N` line from a miner: the streak holds while votes keep coming inside `gap_s`.
+    pub fn on_vote(&mut self, now: f64, index: u64, gap_s: f64) {
+        self.votes_signed += 1;
+        if self.streak_since == 0.0 || (self.last_vote_at > 0.0 && now - self.last_vote_at > gap_s) {
+            self.streak_since = now;
+        }
+        self.last_vote_at = now;
+        if index > self.last_vote_index {
+            self.last_vote_index = index;
+        }
+        if index > 0 && !self.signed_open.contains(&index) {
+            self.signed_open.push(index);
+            if self.signed_open.len() > KEEP_SIGNED {
+                let n = self.signed_open.len() - KEEP_SIGNED;
+                self.signed_open.drain(0..n);
+            }
+        }
+    }
+
+    /// A `LOCK checkpoint N` line: every signed index at or under N is in a locked certificate now.
+    pub fn on_lock(&mut self, index: u64) {
+        let (locked, open): (Vec<u64>, Vec<u64>) = self.signed_open.iter().partition(|&&i| i <= index);
+        if let Some(&top) = locked.iter().max() {
+            if top > self.last_signed_locked {
+                self.last_signed_locked = top;
+            }
+            self.signed_locked_count += locked.len() as u64;
+        }
+        self.signed_open = open;
+    }
+
+    /// The timeline's first-time marks ("synced", "mining"): set once, kept. Returns true when it was new.
+    pub fn mark(&mut self, what: &str, now: f64) -> bool {
+        let slot = match what { "synced" => &mut self.first_synced_at, "mining" => &mut self.first_mining_at, _ => return false };
+        if *slot > 0.0 { return false; }
+        *slot = now;
+        true
+    }
+
+    pub fn on_shard_paid(&mut self, now: f64, block: u64, shard: u64, wei: u128) {
+        if self.shards.iter().any(|s| s.block == block && s.shard == shard) {
+            return;
+        }
+        self.shards.insert(0, ShardPaid { block, shard, wei: wei.to_string(), at: now });
+        self.shards.truncate(KEEP_SHARDS);
+    }
+
+    /// Seconds of unbroken signing at `now` (0 when the last vote is older than `gap_s`).
+    pub fn streak_s(&self, now: f64, gap_s: f64) -> f64 {
+        if self.streak_since == 0.0 || self.last_vote_at == 0.0 || now - self.last_vote_at > gap_s {
+            return 0.0;
+        }
+        (now - self.streak_since).max(0.0)
+    }
+
+    fn blocks_since(&self, from: f64) -> u64 {
+        // the day ring is daily; the finer windows read the block list and fall back to the ring
+        self.days.iter().filter(|d| (d.day as f64 + 1.0) * DAY_S > from).map(|d| d.blocks).sum()
+    }
+
+    pub fn state(&self, now: f64, gap_s: f64) -> LadderState {
+        let today = day_of(now);
+        let window_from = now - 30.0 * DAY_S;
+        let days_mined_30 = self.days.iter().filter(|d| d.blocks > 0 && (d.day as f64 + 1.0) * DAY_S > window_from).count() as u64;
+        LadderState {
+            first_block_at: self.first_block_at,
+            first_block_card: self.first_block_card.clone(),
+            first_block_hash: self.first_block_hash.clone(),
+            first_block_daa: self.first_block_daa,
+            days_mined_30,
+            blocks_30d: self.blocks_since(window_from),
+            blocks_today: self.days.iter().find(|d| d.day == today).map(|d| d.blocks).unwrap_or(0),
+            days: self.days.iter().filter(|d| (d.day as f64 + 1.0) * DAY_S > window_from).cloned().collect(),
+            cards_first: self.cards_first.clone(),
+            blocks: self.blocks.iter().take(10).cloned().collect(),
+            votes_signed: self.votes_signed,
+            last_vote_index: self.last_vote_index,
+            last_vote_at: self.last_vote_at,
+            last_signed_locked: self.last_signed_locked,
+            signed_locked_count: self.signed_locked_count,
+            streak_s: self.streak_s(now, gap_s),
+            shards: self.shards.clone(),
+            milestone: self.milestone.clone(),
+            first_synced_at: self.first_synced_at,
+            first_mining_at: self.first_mining_at,
+        }
+    }
+}
+
+/// The Activity line a milestone raises (the dashboard's EVENT_MAP reads these shapes).
+pub fn milestone_event(m: &Milestone) -> String {
+    match m.kind.as_str() {
+        "first" => format!("first block: found by {} (block card)", m.card_name),
+        "hundred" => format!("block 100 of this machine: found by {} (block card)", m.card_name),
+        "thousand" => format!("block 1,000 of this machine: found by {} (block card)", m.card_name),
+        "ten_thousand" => format!("block {} of this machine: found by {} (block card)", with_commas(m.count), m.card_name),
+        _ => format!("first block on {} (block card)", m.card_name),
+    }
+}
+
+fn with_commas(n: u64) -> String {
+    let s = n.to_string();
+    let mut out = String::new();
+    for (i, c) in s.chars().enumerate() {
+        if i > 0 && (s.len() - i) % 3 == 0 { out.push(','); }
+        out.push(c);
+    }
+    out
+}
+
+fn norm_nonce(n: &str) -> String {
+    let t = n.trim().trim_start_matches("0x").trim_start_matches('0').to_ascii_lowercase();
+    if t.is_empty() && !n.trim().is_empty() { "0".into() } else { t }
+}
+
+/// `PoW accepted <hash> by <engine> (daa N, ..., nonce 0x..)` -> (hash, daa, nonce)
+pub fn parse_node_accepted(text: &str) -> Option<(String, u64, String)> {
+    let rest = text.split("PoW accepted ").nth(1)?;
+    let hash = rest.split_whitespace().next()?.to_string();
+    if hash.len() != 64 || !hash.chars().all(|c| c.is_ascii_hexdigit()) {
+        return None;
+    }
+    let daa = rest.split("(daa ").nth(1)?.split(|c: char| !c.is_ascii_digit()).next()?.parse::<u64>().ok()?;
+    let nonce = rest.split("nonce ").nth(1)?.trim_end_matches(')').split_whitespace().next()?.to_string();
+    Some((hash, daa, nonce))
+}
+
+/// `... ACCEPTED block nonce=0x.. (...)` -> the nonce
+pub fn parse_miner_accepted(text: &str) -> Option<String> {
+    let rest = text.split("ACCEPTED block nonce=").nth(1)?;
+    Some(rest.split_whitespace().next()?.to_string())
+}
+
+/// `... VOTE index=N ...` -> N
+pub fn parse_vote_index(text: &str) -> Option<u64> {
+    text.split("VOTE index=").nth(1)?.split(|c: char| !c.is_ascii_digit()).next()?.parse().ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    const NODE: &str = "2026-10-04 20:08:38.486+00:00 [INFO ] PoW accepted 28abaa8c28ffb4c3eab96b5dc202f8328df7038dc7b2653c9e4b7dd6369ae5ce by igneum-lottery-v2-bound (daa 38637, epoch seed c8b574fbbbd6ba93b34f8c9a81042b6970b140ffb24219e381d82b653673ee81, day 20730, nonce 0x267dd27200a91c80)";
+    const MINER: &str = "1791140918.500 ACCEPTED block nonce=0x267dd27200a91c80 (gpu worker, cpu re-check ok, identity mac-01234567-1)";
+
+    #[test]
+    fn the_node_and_miner_lines_parse() {
+        let (h, daa, n) = parse_node_accepted(NODE).unwrap();
+        assert_eq!(h, "28abaa8c28ffb4c3eab96b5dc202f8328df7038dc7b2653c9e4b7dd6369ae5ce");
+        assert_eq!(daa, 38637);
+        assert_eq!(n, "0x267dd27200a91c80");
+        assert_eq!(parse_miner_accepted(MINER).unwrap(), "0x267dd27200a91c80");
+        assert_eq!(parse_vote_index("1791140918.500 VOTE index=1240 checkpoint=abcd signed").unwrap(), 1240);
+        assert!(parse_node_accepted("PoW rejected 00 by x").is_none());
+    }
+
+    #[test]
+    fn the_first_block_is_matched_to_its_hash_by_nonce_and_raises_the_first_card() {
+        let mut l = Ladder::default();
+        let (h, daa, n) = parse_node_accepted(NODE).unwrap();
+        l.on_node_accepted(&h, daa, &n);
+        // a relayed block from another miner sits in pending too and never matches
+        l.on_node_accepted("ef21a8454b2f3fcaf6c32a8b9c959df936770edfdffff61c7198989d9431ea4b", 38643, "0x4bc93aba007eabaa");
+        let m = l.on_block(1_791_140_918.5, "apple::Apple M5 Max", "Apple M5 Max", &parse_miner_accepted(MINER).unwrap(), 1).unwrap();
+        assert_eq!(m.kind, "first");
+        assert_eq!(m.hash, h);
+        assert_eq!(m.daa, 38637);
+        assert_eq!(l.first_block_hash, h);
+        assert_eq!(l.first_block_daa, 38637);
+        assert_eq!(l.first_block_card, "apple::Apple M5 Max");
+        assert_eq!(l.blocks.len(), 1);
+        assert_eq!(l.pending.len(), 1, "the relayed block stays unmatched");
+        let s = l.state(1_791_140_920.0, 600.0);
+        assert_eq!(s.days_mined_30, 1);
+        assert_eq!(s.blocks_30d, 1);
+        assert_eq!(s.blocks_today, 1);
+    }
+
+    #[test]
+    fn a_miner_line_before_the_node_line_gets_its_hash_filled_in() {
+        let mut l = Ladder::default();
+        l.on_block(100.0, "c", "Card", "0x267dd27200a91c80", 1);
+        assert_eq!(l.first_block_hash, "");
+        let (h, daa, n) = parse_node_accepted(NODE).unwrap();
+        l.on_node_accepted(&h, daa, &n);
+        assert_eq!(l.blocks[0].hash, h);
+        assert_eq!(l.first_block_hash, h);
+        assert_eq!(l.milestone.as_ref().unwrap().hash, h);
+        assert_eq!(l.milestone.as_ref().unwrap().daa, 38637);
+    }
+
+    #[test]
+    fn the_cards_come_at_1_100_1000_10000_and_on_a_new_card() {
+        let mut l = Ladder::default();
+        let mut kinds = vec![];
+        for total in 1..=1_000u64 {
+            if let Some(m) = l.on_block(1000.0 + total as f64, "a", "A", "", total) { kinds.push((total, m.kind)); }
+        }
+        assert_eq!(kinds, vec![(1, "first".to_string()), (100, "hundred".to_string()), (1000, "thousand".to_string())]);
+        assert_eq!(l.on_block(5000.0, "b", "B", "", 1001).unwrap().kind, "card");
+        assert!(l.on_block(5001.0, "b", "B", "", 1002).is_none());
+        assert_eq!(l.on_block(5002.0, "a", "A", "", 10_000).unwrap().kind, "ten_thousand");
+        assert_eq!(l.on_block(5003.0, "a", "A", "", 20_000).unwrap().kind, "ten_thousand");
+        assert_eq!(l.blocks.len(), KEEP_BLOCKS);
+    }
+
+    #[test]
+    fn days_mined_counts_distinct_days_inside_the_window_only() {
+        let mut l = Ladder::default();
+        let now = 40.0 * DAY_S + 100.0;
+        // blocks on days 5, 20, 20, 39 and 40 (today); day 5 is outside the 30-day window
+        for (d, total) in [(5.0, 1), (20.0, 2), (20.0, 3), (39.0, 4), (40.0, 5)] {
+            l.on_block(d * DAY_S + 50.0, "a", "A", "", total);
+        }
+        let s = l.state(now, 600.0);
+        assert_eq!(s.days_mined_30, 3);
+        assert_eq!(s.blocks_30d, 4);
+        assert_eq!(s.blocks_today, 1);
+        assert_eq!(s.days.len(), 3);
+    }
+
+    #[test]
+    fn the_signing_streak_holds_across_votes_and_breaks_on_a_gap() {
+        let mut l = Ladder::default();
+        l.on_vote(1000.0, 10, 600.0);
+        l.on_vote(1030.0, 11, 600.0);
+        l.on_vote(1060.0, 12, 600.0);
+        assert_eq!(l.streak_s(1090.0, 600.0), 90.0);
+        assert_eq!(l.votes_signed, 3);
+        assert_eq!(l.last_vote_index, 12);
+        // the lock at 11 puts 10 and 11 in locked certificates; 12 stays open
+        l.on_lock(11);
+        assert_eq!(l.last_signed_locked, 11);
+        assert_eq!(l.signed_locked_count, 2);
+        assert_eq!(l.signed_open, vec![12]);
+        // a gap longer than the presence window ends the streak; the next vote starts a new one
+        assert_eq!(l.streak_s(1700.0, 600.0), 0.0);
+        l.on_vote(1700.0, 33, 600.0);
+        assert_eq!(l.streak_s(1730.0, 600.0), 30.0);
+        assert_eq!(l.state(1730.0, 600.0).streak_s, 30.0);
+    }
+
+    #[test]
+    fn the_milestone_events_read_in_the_users_words() {
+        let m = |kind: &str, count: u64| Milestone { kind: kind.into(), count, card: "a".into(), card_name: "RTX 4070".into(), hash: String::new(), daa: 0, at: 0.0 };
+        assert_eq!(milestone_event(&m("first", 1)), "first block: found by RTX 4070 (block card)");
+        assert_eq!(milestone_event(&m("hundred", 100)), "block 100 of this machine: found by RTX 4070 (block card)");
+        assert_eq!(milestone_event(&m("ten_thousand", 20_000)), "block 20,000 of this machine: found by RTX 4070 (block card)");
+        assert_eq!(milestone_event(&m("card", 7)), "first block on RTX 4070 (block card)");
+    }
+
+    #[test]
+    fn the_timeline_marks_are_set_once() {
+        let mut l = Ladder::default();
+        assert!(l.mark("synced", 10.0));
+        assert!(!l.mark("synced", 20.0));
+        assert!(l.mark("mining", 30.0));
+        assert!(!l.mark("other", 40.0));
+        let s = l.state(50.0, 600.0);
+        assert_eq!(s.first_synced_at, 10.0);
+        assert_eq!(s.first_mining_at, 30.0);
+    }
+
+    #[test]
+    fn paid_shards_are_kept_once_each_newest_first() {
+        let mut l = Ladder::default();
+        l.on_shard_paid(10.0, 1_284_117, 3, 1_150_000_000_000_000_000);
+        l.on_shard_paid(11.0, 1_284_117, 3, 1_150_000_000_000_000_000);
+        l.on_shard_paid(12.0, 1_284_120, 0, 2_000_000_000_000_000_000);
+        assert_eq!(l.shards.len(), 2);
+        assert_eq!(l.shards[0].block, 1_284_120);
+        assert_eq!(l.shards[1].wei, "1150000000000000000");
+    }
+
+    #[test]
+    fn the_record_survives_a_save_and_load() {
+        let mut l = Ladder::default();
+        l.on_block(100.0, "a", "A", "0x1", 1);
+        l.on_vote(130.0, 5, 600.0);
+        let dir = std::env::temp_dir().join(format!("igneum-ladder-test-{}", std::process::id()));
+        let path = dir.join("ladder.json");
+        l.save(&path);
+        let back = Ladder::load(&path);
+        assert_eq!(back.first_block_at, 100.0);
+        assert_eq!(back.votes_signed, 1);
+        assert_eq!(back.blocks, l.blocks);
+        let _ = std::fs::remove_dir_all(&dir);
+        assert_eq!(Ladder::load(&dir.join("missing.json")).votes_signed, 0);
+    }
+}

app/igneum-app/src/live.rs

@@ -0,0 +1,141 @@
+//! GET /api/live for the dashboard's chain scene (ui/live-dag.js, the site's module). The scene wants the network's
+//! blocks over the last minutes with lanes, parents, colours, the selected chain, checkpoints and proof state. The
+//! local node speaks gRPC and wRPC only and the engine carries no client for either (no TLS, no websocket stack), so
+//! this reads the observer's /api/live (the same URL ota.rs already polls for the identity count) through curl, caches
+//! it for 2 s, and marks this machine's blocks: the observer names a block's miner by the first 8 hex of its vote key
+//! hash, and every card's `ids` carry the same 8 characters for this machine's keys, so a match becomes the lane "you".
+//! Read-only; one upstream call per 2 s whatever the window asks. A local-node source is owed (a JSON RPC on igneumd or
+//! a wRPC client here); the shape stays the same when it comes.
+use serde_json::{json, Value};
+use std::collections::HashSet;
+use std::process::Command;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+
+static CACHE: Mutex<Option<(Instant, u32, Value)>> = Mutex::new(None);
+const TTL: Duration = Duration::from_secs(2);
+
+/// The observer's reply with this machine's lane marked. `ids` are the 8-character vote key ids of this machine's
+/// cards. Blocks whose `miner` is one of them read `miner: "you"`; `state.you_blocks` counts them; `state.source` is "site"
+/// (the 0.3.16 engine's live.rs answers "node" when igneumd carries igneum_getRecentBlocks). Anything else passes through untouched, so the module's contract holds.
+pub fn shape(mut reply: Value, ids: &HashSet<String>) -> Value {
+    let mut yours = 0u64;
+    if let Some(blocks) = reply.get_mut("blocks").and_then(|b| b.as_array_mut()) {
+        for b in blocks.iter_mut() {
+            let mine = b.get("miner").and_then(|m| m.as_str()).map(|m| ids.contains(m)).unwrap_or(false);
+            if mine {
+                yours += 1;
+                if let Some(o) = b.as_object_mut() { o.insert("miner".into(), json!("you")); }
+            }
+        }
+    }
+    if let Some(st) = reply.get_mut("state").and_then(|s| s.as_object_mut()) {
+        st.insert("you_blocks".into(), json!(yours));
+        st.insert("source".into(), json!("site"));
+    }
+    reply
+}
+
+/// The observer URL for a window: `<live_api>?window=<s>`, the window clamped to the module's 30 to 300 s.
+pub fn url_for(live_api: &str, window_s: u32) -> String {
+    format!("{live_api}?window={}", window_s.clamp(30, 300))
+}
+
+/// The reply for the dashboard: cached 2 s per window; `{ok:false, error}` when the observer is unreachable or the
+/// build has no observer address (the UI then draws its own blocks strip).
+pub fn fetch(live_api: &str, window_s: u32, ids: &HashSet<String>) -> Value {
+    if live_api.is_empty() {
+        return json!({ "ok": false, "error": "no observer address in this build" });
+    }
+    let window_s = window_s.clamp(30, 300);
+    if let Some((at, w, v)) = CACHE.lock().unwrap().as_ref() {
+        if *w == window_s && at.elapsed() < TTL { return v.clone(); }
+    }
+    let url = url_for(live_api, window_s);
+    let out = crate::detect::run_timeout(
+        Command::new(crate::platform::tool("curl")).args(["-s", "--max-time", "4", &url]),
+        None,
+        Duration::from_secs(6),
+    );
+    let reply = match out.and_then(|t| serde_json::from_str::<Value>(&t).ok()) {
+        Some(v) if v.get("ok").and_then(|o| o.as_bool()).unwrap_or(false) && v.get("blocks").map(|b| b.is_array()).unwrap_or(false) => shape(v, ids),
+        _ => json!({ "ok": false, "error": "the observer did not answer" }),
+    };
+    if reply.get("ok").and_then(|o| o.as_bool()).unwrap_or(false) {
+        *CACHE.lock().unwrap() = Some((Instant::now(), window_s, reply.clone()));
+    }
+    reply
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+
+    // a fixture in the observer's shape (site/api/live.mjs): three miners, this machine is 8fafda27, one of its blocks on
+    // the selected chain and proven, one excluded; a locked and a pending checkpoint
+    fn fixture() -> Value {
+        json!({
+            "ok": true, "now": 1791301670,
+            "state": { "stale": false, "age_s": 1, "height": 198490 },
+            "blocks": [
+                { "hash": "a1", "ts": 1791301600000i64, "blue_score": 194690, "daa": 198486, "parents": [], "chain": true, "color": "blue", "miner": "8fafda27", "locked": true, "final": true, "shards": [{ "state": "paid" }], "proven": true },
+                { "hash": "a2", "ts": 1791301601000i64, "blue_score": 194691, "daa": 198487, "parents": ["a1"], "chain": true, "color": "blue", "miner": "1b2c3d4e", "locked": false, "final": false, "shards": [{ "state": "proving" }], "proven": false },
+                { "hash": "a3", "ts": 1791301601500i64, "blue_score": null, "daa": 198487, "parents": ["a1"], "chain": false, "color": "red", "miner": "8fafda27", "locked": false, "final": false, "shards": [], "proven": false },
+                { "hash": "a4", "ts": 1791301602000i64, "blue_score": 194692, "daa": 198488, "parents": ["a2", "a3"], "chain": true, "color": "pending", "miner": "deadbeef", "locked": false, "final": false, "shards": [], "proven": false }
+            ],
+            "finality": { "checkpoints": [
+                { "index": 6490, "blue_score": 194690, "daa": 198486, "state": "locked", "fraction_total": 0.71 },
+                { "index": 6491, "blue_score": 194720, "daa": 198516, "state": "pending", "fraction_total": 0.44 }
+            ] }
+        })
+    }
+
+    #[test]
+    fn this_machines_blocks_become_the_lane_you_and_nothing_else_moves() {
+        let ids: HashSet<String> = ["8fafda27".to_string(), "9a8b7c6d".to_string()].into_iter().collect();
+        let out = shape(fixture(), &ids);
+        let blocks = out["blocks"].as_array().unwrap();
+        assert_eq!(blocks.len(), 4);
+        assert_eq!(blocks[0]["miner"], "you");
+        assert_eq!(blocks[2]["miner"], "you");
+        assert_eq!(blocks[1]["miner"], "1b2c3d4e");
+        assert_eq!(blocks[3]["miner"], "deadbeef");
+        // the rest of the contract passes through: parents, chain, colour, proof state, checkpoints
+        assert_eq!(blocks[3]["parents"], json!(["a2", "a3"]));
+        assert_eq!(blocks[0]["chain"], true);
+        assert_eq!(blocks[2]["color"], "red");
+        assert_eq!(blocks[0]["proven"], true);
+        assert_eq!(blocks[1]["shards"][0]["state"], "proving");
+        assert_eq!(out["finality"]["checkpoints"].as_array().unwrap().len(), 2);
+        assert_eq!(out["finality"]["checkpoints"][0]["state"], "locked");
+        assert_eq!(out["state"]["you_blocks"], 2);
+        assert_eq!(out["state"]["source"], "site");
+        assert_eq!(out["state"]["height"], 198490);
+        assert_eq!(out["ok"], true);
+    }
+
+    #[test]
+    fn no_ids_means_no_lane_is_yours_and_a_bare_reply_survives() {
+        let out = shape(fixture(), &HashSet::new());
+        assert!(out["blocks"].as_array().unwrap().iter().all(|b| b["miner"] != "you"));
+        assert_eq!(out["state"]["you_blocks"], 0);
+        let bare = shape(json!({ "ok": true, "blocks": [] }), &HashSet::new());
+        assert_eq!(bare["blocks"].as_array().unwrap().len(), 0);
+        assert!(bare.get("state").is_none(), "no state object is invented");
+    }
+
+    #[test]
+    fn the_window_is_clamped_to_the_modules_range() {
+        assert_eq!(url_for("https://igneum.network/api/live", 120), "https://igneum.network/api/live?window=120");
+        assert_eq!(url_for("https://igneum.network/api/live", 5), "https://igneum.network/api/live?window=30");
+        assert_eq!(url_for("https://igneum.network/api/live", 9000), "https://igneum.network/api/live?window=300");
+    }
+
+    #[test]
+    fn a_build_without_an_observer_address_says_so() {
+        let out = fetch("", 120, &HashSet::new());
+        assert_eq!(out["ok"], false);
+        assert_eq!(out["error"], "no observer address in this build");
+    }
+}

app/igneum-app/src/main.rs

@@ -24,6 +24,7 @@ mod server;
 mod state;
 mod manifest;
 mod ota;
+mod uiota;
 mod update;
 mod jobs;
 mod jobrun;
@@ -37,6 +38,12 @@ mod sweep;
 mod ember;
 mod powertask;
 mod watchdog;
+mod live;
+mod extnode;
+mod merge;
+mod ladder;
+mod chainfacts;
+mod card;
 
 use std::io::{BufRead, Write};
 use std::sync::mpsc::channel;

app/igneum-app/src/manifest.rs

@@ -12,8 +12,13 @@
 //!   "platforms": { "mac": {"url","sha256","size","kind":"dmg"|"zip"}, "windows": {"url","sha256","size","kind":"inno-setup"} },
 //!   "min_supported_version": "0.3.0", "notes": "one line",
 //!   "consensus": { "activation_height": null|number, "deadline_note": "", "override": {...} },
-//!   "tuning": { "updated": "...", "cards": { "<card model>": { "variant": "u2", "race": true, "candidates": [..] } } }
+//!   "tuning": { "updated": "...", "cards": { "<card model>": { "variant": "u2", "race": true, "candidates": [..] } } },
+//!   "ui": { "version": "0.3.19.1", "sha256": "<64 hex>", "size": 412345, "url": "https://dl.../ui/igneum-ui-0.3.19.1.tar.gz",
+//!           "min_engine": "0.3.19", "signature": "<128 hex>" }
 //! }
+//! `ui` (7 October 2026, docs/plans/ui-ota.md) is the interface channel: a tar.gz of app/igneum-app/ui the engine serves
+//! in place of its embedded copy once the hash and the entry's own Ed25519 signature (over `ui_sign_bytes`, the same
+//! release key) check; the whole manifest's signature covers it too. Removing the object is the kill switch.
 //! A platform that is missing is not updated (the Windows build lands later than the Mac one).
 //! `tuning` (4 October 2026, docs/design/miner-tuning.md) is the fleet's per-card kernel tuning: the engine writes it
 //! to <app data>/tuning.json and every GPU worker reads it at its next prepare (IGNEUM_TUNING_FILE).
@@ -59,6 +64,34 @@ pub struct Manifest {
     /// tuning: the per-card kernel tuning object (tools/tuning.mjs writes it, publish-manifest.sh --tuning carries
     /// it), written as is to <app data>/tuning.json for the GPU workers; signed with the rest of the manifest.
     pub tuning: Option<serde_json::Value>,
+    /// ui: the interface channel (src/uiota.rs); None = no over-the-air interface is published
+    pub ui: Option<UiEntry>,
+}
+
+/// One published interface bundle (the manifest's `ui` object).
+#[derive(Clone, Debug, PartialEq, Default)]
+pub struct UiEntry {
+    pub version: String,
+    pub sha256: String,
+    pub size: u64,
+    pub url: String,
+    /// the lowest engine version that may serve this bundle; a newer bundle for an older engine is ignored
+    pub min_engine: String,
+    /// Ed25519 over `ui_sign_bytes(version, sha256, min_engine)` by the release key, 128 hex
+    pub signature: String,
+}
+
+/// The bytes the interface entry's own signature covers: a fixed tag, then the version, the hash and the engine
+/// floor, one per line. The url and the size are not covered: the hash is what the engine trusts after the download.
+pub fn ui_sign_bytes(version: &str, sha256: &str, min_engine: &str) -> Vec<u8> {
+    format!("igneum-ui\n{version}\n{}\n{min_engine}\n", sha256.to_ascii_lowercase()).into_bytes()
+}
+
+/// The entry's own signature against the release key (the whole manifest's signature is checked before this).
+pub fn verify_ui_entry(e: &UiEntry, pub_hex: &str) -> Result<(), String> {
+    let key = public_key(pub_hex)?;
+    let sig = hex_decode(&e.signature).and_then(|b| Signature::from_slice(&b).ok()).ok_or("interface signature is not 128 hex characters")?;
+    key.verify(&ui_sign_bytes(&e.version, &e.sha256, &e.min_engine), &sig).map_err(|_| "interface signature does not verify".to_string())
 }
 
 impl Manifest {
@@ -168,6 +201,32 @@ pub fn parse(text: &str) -> Result<Manifest, String> {
             Some(t) if !t.is_null() => return Err("tuning must be an object with a cards object".into()),
             _ => None,
         },
+        ui: match v.get("ui") {
+            Some(u) if u.is_object() => {
+                let e = UiEntry { version: s(u, "version"), sha256: s(u, "sha256").to_ascii_lowercase(), size: u.get("size").and_then(|x| x.as_u64()).unwrap_or(0), url: s(u, "url"), min_engine: s(u, "min_engine"), signature: s(u, "signature").to_ascii_lowercase() };
+                if parse_version(&e.version).is_none() {
+                    return Err(format!("ui: version '{}' is not a version", e.version));
+                }
+                if parse_version(&e.min_engine).is_none() {
+                    return Err(format!("ui: min_engine '{}' is not a version", e.min_engine));
+                }
+                if !e.url.starts_with("https://") && !e.url.starts_with("http://127.0.0.1:") {
+                    return Err("ui: the url is not https".into());
+                }
+                if e.sha256.len() != 64 || !e.sha256.chars().all(|c| c.is_ascii_hexdigit()) {
+                    return Err("ui: sha256 is not 64 hex characters".into());
+                }
+                if e.size == 0 {
+                    return Err("ui: size is missing".into());
+                }
+                if e.signature.len() != 128 || !e.signature.chars().all(|c| c.is_ascii_hexdigit()) {
+                    return Err("ui: signature is not 128 hex characters".into());
+                }
+                Some(e)
+            }
+            Some(u) if !u.is_null() => return Err("ui must be an object".into()),
+            _ => None,
+        },
     })
 }
 
@@ -300,6 +359,10 @@ pub struct Moment {
     pub boundary_eta_s: Option<i64>,
     /// A worker is starting, exporting a pack or being built: let it finish.
     pub miner_busy: bool,
+    /// A remote job is running on this engine (src/jobrun.rs). It holds even an urgent install: a job is bounded by its
+    /// cap, and an install under it kills its process tree (PC 1, 6 October 2026, 17:52:54Z: 0.3.14 went in during a
+    /// measurement job because install_asked from a two-hour-old update-now still counted as urgent).
+    pub job_active: bool,
     /// How long the update has been ready and waiting.
     pub ready_for_s: u64,
     /// A consensus activation is close, or this version is below min_supported_version: now beats later.
@@ -320,6 +383,9 @@ pub fn slot_minute(id8: &str) -> u64 {
 
 /// Ok when the update may be applied now; Err carries the reason to wait, in the words the dashboard shows.
 pub fn safe_to_apply(m: &Moment) -> Result<(), String> {
+    if m.job_active {
+        return Err("a remote job is running; installing when it closes".into());
+    }
     if m.urgent {
         return Ok(());
     }
@@ -382,6 +448,36 @@ mod tests {
         assert_eq!(ours, theirs);
     }
 
+    #[test]
+    fn the_ui_entry_parses_and_every_bad_field_fails() {
+        use ed25519_dalek::{Signer, SigningKey};
+        let sk = SigningKey::from_bytes(&[3u8; 32]);
+        let pk = hex_encode(sk.verifying_key().as_bytes());
+        let sha = "ab".repeat(32);
+        let sig = hex_encode(&sk.sign(&ui_sign_bytes("1.0.1", &sha, "0.3.19")).to_bytes());
+        let base = serde_json::json!({ "version": "0.3.19", "platforms": {}, "ui": { "version": "1.0.1", "sha256": sha, "size": 400000, "url": "https://dl.igneum.network/dl/t/ui/igneum-ui-1.0.1.tar.gz", "min_engine": "0.3.19", "signature": sig } });
+        let m = parse(&base.to_string()).unwrap();
+        let u = m.ui.clone().unwrap();
+        assert_eq!(u.version, "1.0.1");
+        assert_eq!(u.min_engine, "0.3.19");
+        assert!(verify_ui_entry(&u, &pk).is_ok());
+        let mut t = u.clone();
+        t.sha256 = "00".repeat(32);
+        assert!(verify_ui_entry(&t, &pk).is_err(), "a changed hash breaks the entry's signature");
+        let mut t = u.clone();
+        t.min_engine = "0.3.0".into();
+        assert!(verify_ui_entry(&t, &pk).is_err(), "a changed engine floor breaks it too");
+        assert!(verify_ui_entry(&u, &hex_encode(SigningKey::from_bytes(&[4u8; 32]).verifying_key().as_bytes())).is_err());
+        assert_eq!(parse(r#"{"version":"0.3.19","platforms":{}}"#).unwrap().ui, None, "no ui object: the kill switch");
+        for (k, v) in [("version", serde_json::json!("x")), ("min_engine", serde_json::json!("")), ("url", serde_json::json!("http://evil/x.tar.gz")), ("sha256", serde_json::json!("abc")), ("size", serde_json::json!(0)), ("signature", serde_json::json!("zz"))] {
+            let mut b = base.clone();
+            b["ui"][k] = v;
+            assert!(parse(&b.to_string()).is_err(), "ui.{k} bad must fail");
+        }
+        assert!(parse(r#"{"version":"0.3.19","platforms":{},"ui":"x"}"#).is_err());
+        assert_eq!(std::str::from_utf8(&ui_sign_bytes("1.0.1", "AB", "0.3.19")).unwrap(), "igneum-ui\n1.0.1\nab\n0.3.19\n");
+    }
+
     #[test]
     fn tuning_parses() {
         let m = parse(r#"{"version":"0.3.4","platforms":{},"tuning":{"updated":"2026-10-04T20:00:00Z","cards":{"NVIDIA_GeForce_RTX_5090":{"variant":"u2-ldg","race":true,"candidates":["u2-ldg","ldg","base"]}}}}"#).unwrap();
@@ -492,7 +588,7 @@ mod tests {
 
     #[test]
     fn safe_moments() {
-        let base = Moment { node_synced: true, boundary_eta_s: Some(1800), miner_busy: false, ready_for_s: 60, urgent: false, slot_ok: true, network_drop_pct: 0.0 };
+        let base = Moment { node_synced: true, boundary_eta_s: Some(1800), miner_busy: false, job_active: false, ready_for_s: 60, urgent: false, slot_ok: true, network_drop_pct: 0.0 };
         assert!(safe_to_apply(&base).is_ok());
         assert_eq!(safe_to_apply(&Moment { node_synced: false, ..base.clone() }).unwrap_err(), "waiting for the node to sync");
         assert!(safe_to_apply(&Moment { boundary_eta_s: Some(120), ..base.clone() }).unwrap_err().contains("boundary in 120 s"));
@@ -502,6 +598,11 @@ mod tests {
         assert!(safe_to_apply(&Moment { miner_busy: true, ..base.clone() }).unwrap_err().contains("worker"));
         // urgent beats every wait
         assert!(safe_to_apply(&Moment { node_synced: false, boundary_eta_s: Some(5), miner_busy: true, urgent: true, ..base.clone() }).is_ok());
+        // PC 1, 6 October 2026, 17:52:54Z: a scheduled update arriving mid-job is deferred to the job's close, urgent or not
+        assert!(safe_to_apply(&Moment { job_active: true, ..base.clone() }).unwrap_err().contains("remote job"));
+        assert!(safe_to_apply(&Moment { job_active: true, urgent: true, ..base.clone() }).unwrap_err().contains("remote job"));
+        assert!(safe_to_apply(&Moment { job_active: true, urgent: true, slot_ok: false, ..base.clone() }).is_err());
+        assert!(safe_to_apply(&Moment { job_active: false, urgent: true, slot_ok: false, ..base.clone() }).is_ok());
         // patience: an unsynced node for 6 h applies anyway
         assert!(safe_to_apply(&Moment { node_synced: false, ready_for_s: SAFE_MOMENT_PATIENCE_S, ..base.clone() }).is_ok());
         assert!(safe_to_apply(&Moment { node_synced: false, ready_for_s: SAFE_MOMENT_PATIENCE_S - 1, ..base.clone() }).is_err());

app/igneum-app/src/merge.rs

@@ -0,0 +1,96 @@
+//! Is this node's work merging into the network? (design note for 0.3.18, 7 October 2026, from the node lane's 30-s
+//! propagation reading: a node behind a slow link keeps mining its own chain, its relayed blocks never merge, and the
+//! N4 "synced" test (tip moving, a peer present) cannot see it.)
+//!
+//! The decision is pure. The engine feeds it our sink's blue score (the watch line's `blue=`), the sinks the network
+//! reports (the observer's view, and any peer that answers igneum_getNodeInfo), the merge depth from the node's params,
+//! how long ago one of our blocks was last seen in the network's view, and how long we have been mining.
+
+/// How long our blocks may stay out of the network's view before the node reads "behind" (two minutes).
+pub const NOT_MERGING_S: f64 = 120.0;
+/// The merge depth when the node does not say (node lane, 7 October 2026: 1 bps x MERGE_DEPTH_DURATION = 3,600 in blue
+/// score on the devnet and every 1-bps network; 36,000 at 10 bps; read from igneum_getNodeInfo's `blockrate.mergeDepth`
+/// once the node carries it). Peer sinks: nothing exposes them yet; `igneum_getPeers` with lastDeliveredBlueScore is on
+/// the 0.3.19 list, and the observer is the only network view until then.
+pub const DEFAULT_MERGE_DEPTH: u64 = 3_600;
+/// The words every surface uses for this state.
+pub const NOT_MERGING: &str = "behind: your blocks are not merging into the network";
+
+#[derive(Debug, Clone, Default)]
+pub struct MergeCheck {
+    /// our node's sink blue score
+    pub our_blue: u64,
+    /// the sinks' blue scores the network reports (observer, peers); empty = no view, no decision
+    pub peer_sinks: Vec<u64>,
+    /// the merge depth in blue score (the node's params, else DEFAULT_MERGE_DEPTH)
+    pub merge_depth: u64,
+    /// seconds since one of our blocks last appeared in the network's view; None = never seen
+    pub ours_seen_ago_s: Option<f64>,
+    /// how long this machine has been mining with a synced node, in seconds
+    pub mining_for_s: f64,
+}
+
+/// True when every sink the network reports is more than the merge depth ahead of ours and none of our blocks has
+/// appeared in the network's view for NOT_MERGING_S (so the miner's blocks can no longer merge: hold it).
+pub fn not_merging(c: &MergeCheck) -> bool {
+    if c.peer_sinks.is_empty() || c.mining_for_s < NOT_MERGING_S {
+        return false;
+    }
+    let depth = if c.merge_depth == 0 { DEFAULT_MERGE_DEPTH } else { c.merge_depth };
+    let all_ahead = c.peer_sinks.iter().all(|&s| s > c.our_blue.saturating_add(depth));
+    let ours_absent = c.ours_seen_ago_s.map(|a| a >= NOT_MERGING_S).unwrap_or(true);
+    all_ahead && ours_absent
+}
+
+/// The network's view out of an observer reply (crate::live::fetch's shape): the highest blue score it shows, and the
+/// newest timestamp (unix ms) of a block it marks as ours (miner "you"). None when the reply carries no blocks.
+pub fn view_of(reply: &serde_json::Value) -> Option<(u64, Option<i64>)> {
+    let blocks = reply.get("blocks")?.as_array()?;
+    if blocks.is_empty() {
+        return None;
+    }
+    let sink = blocks.iter().filter_map(|b| b.get("blue_score").and_then(|v| v.as_u64())).max().unwrap_or(0);
+    let ours = blocks.iter().filter(|b| b.get("miner").and_then(|m| m.as_str()) == Some("you")).filter_map(|b| b.get("ts").and_then(|v| v.as_i64())).max();
+    Some((sink, ours))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn c() -> MergeCheck { MergeCheck { our_blue: 100_000, peer_sinks: vec![104_000, 103_800], merge_depth: 3_600, ours_seen_ago_s: None, mining_for_s: 600.0 } }
+
+    /// The slow-link node (node lane, 30-s propagation reading): tip moving, a peer present, its own chain, nothing
+    /// merging. Today's sync test calls it synced; this one holds the miner.
+    #[test]
+    fn a_node_whose_blocks_never_merge_reads_behind_and_holds_the_miner() {
+        assert!(not_merging(&c()), "every peer more than the merge depth ahead and ours never seen");
+        assert!(not_merging(&MergeCheck { ours_seen_ago_s: Some(130.0), ..c() }), "ours last seen over two minutes ago");
+        assert_eq!(NOT_MERGING, "behind: your blocks are not merging into the network");
+    }
+
+    #[test]
+    fn a_merging_node_is_left_alone() {
+        assert!(!not_merging(&MergeCheck { ours_seen_ago_s: Some(20.0), ..c() }), "our block appeared in the network's view");
+        assert!(!not_merging(&MergeCheck { peer_sinks: vec![104_000, 101_000], ..c() }), "one peer within the merge depth");
+        assert!(!not_merging(&MergeCheck { peer_sinks: vec![103_600], ..c() }), "exactly the merge depth is not over it");
+        assert!(!not_merging(&MergeCheck { peer_sinks: vec![], ..c() }), "no network view, no decision");
+        assert!(!not_merging(&MergeCheck { mining_for_s: 30.0, ..c() }), "not mining long enough to judge");
+        assert!(not_merging(&MergeCheck { merge_depth: 0, peer_sinks: vec![103_601], ..c() }), "a missing depth falls back to 3,600");
+    }
+
+    #[test]
+    fn the_observer_reply_gives_the_sink_and_our_newest_block() {
+        let r = json!({ "blocks": [
+            { "blue_score": 194_690, "ts": 1_791_301_600_000i64, "miner": "8fafda27" },
+            { "blue_score": 194_692, "ts": 1_791_301_602_000i64, "miner": "you" },
+            { "blue_score": null, "ts": 1_791_301_601_500i64, "miner": "you" },
+            { "blue_score": 194_691, "ts": 1_791_301_601_000i64, "miner": "deadbeef" } ] });
+        assert_eq!(view_of(&r), Some((194_692, Some(1_791_301_602_000))));
+        let none_ours = json!({ "blocks": [{ "blue_score": 5, "ts": 1, "miner": "x" }] });
+        assert_eq!(view_of(&none_ours), Some((5, None)));
+        assert_eq!(view_of(&json!({ "blocks": [] })), None);
+        assert_eq!(view_of(&json!({ "ok": false })), None);
+    }
+}

app/igneum-app/src/ota.rs

@@ -70,6 +70,8 @@ pub struct Ctx {
     pub node_synced: bool,
     pub boundary_eta_s: Option<i64>,
     pub miner_busy: bool,
+    /// A remote job is running (src/jobrun.rs): the install holds, urgent or not.
+    pub job_active: bool,
     pub daa: u64,
 }
 
@@ -129,6 +131,9 @@ pub struct Updater {
     live_next: Instant,
     live_busy: bool,
     live_api: String,
+    /// ui-ota: the interface entry of the last verified manifest, handed to src/uiota.rs once per check
+    /// (Some(None) = the channel was withdrawn: the kill switch)
+    ui_change: Option<Option<manifest::UiEntry>>,
 }
 
 impl Updater {
@@ -176,6 +181,7 @@ impl Updater {
             live_next: now,
             live_busy: false,
             live_api: env("IGNEUM_APP_LIVE_API").unwrap_or_else(|| live_api_from(&shared.packaged.live_page)),
+            ui_change: None,
         };
         shared.log(&format!("update slot: minute {} of every hour (machine id {})", u.slot, shared.runtime.id8()));
         #[cfg(windows)]
@@ -271,6 +277,10 @@ impl Updater {
     }
 
     /// The tuning file, once per change (the engine only logs it: the workers read the file at their next prepare).
+    /// ui-ota: the interface entry of the last check, once (None until a check has run)
+    pub fn take_ui_change(&mut self) -> Option<Option<manifest::UiEntry>> {
+        self.ui_change.take()
+    }
     pub fn take_tuning_change(&mut self) -> Option<PathBuf> {
         self.tuning_changed.take()
     }
@@ -539,7 +549,7 @@ impl Updater {
         }
         let slot_ok = minute == self.slot || catch_up || std::env::var("IGNEUM_APP_UPDATE_NO_SLOT").map(|v| v == "1").unwrap_or(false);
         let ready_for = self.ready_since.map(|t| now.duration_since(t).as_secs()).unwrap_or(0);
-        let moment = Moment { node_synced: ctx.node_synced, boundary_eta_s: ctx.boundary_eta_s, miner_busy: ctx.miner_busy, ready_for_s: ready_for, urgent: urgent || self.install_asked, slot_ok, network_drop_pct };
+        let moment = Moment { node_synced: ctx.node_synced, boundary_eta_s: ctx.boundary_eta_s, miner_busy: ctx.miner_busy, job_active: ctx.job_active, ready_for_s: ready_for, urgent: urgent || self.install_asked, slot_ok, network_drop_pct };
         if !self.auto && !urgent && !self.install_asked {
             shared.state.lock().unwrap().update.wait = "waiting for Install now (automatic updates are off)".into();
             return None;
@@ -668,6 +678,12 @@ impl Updater {
                                 shared.log(&format!("update check: {} is published but has no {} build yet", m.version, manifest::platform_name()));
                             } else {
                                 shared.log(&format!("update check: {} is current (manifest {})", self.current, m.version));
+                                // an asked install (update-now) covers this one check: nothing newer, so the ask is spent.
+                                // Left true it made the NEXT manifest urgent hours later (PC 1, 6 October 2026, 17:52:54Z).
+                                if self.install_asked {
+                                    self.install_asked = false;
+                                    shared.log("update check: Install now asked and nothing newer is published; the ask is spent (the next manifest takes the usual slot)");
+                                }
                             }
                             self.entry = None;
                             self.file = None;
@@ -678,6 +694,7 @@ impl Updater {
                         self.min_supported = m.min_supported_version.clone();
                         self.write_override(shared, &m);
                         self.write_tuning(shared, &m);
+                        self.ui_change = Some(m.ui.clone());
                         if let Some(e) = entry {
                             if changed {
                                 self.file = None;
@@ -954,7 +971,7 @@ impl Updater {
 // ---- the threads ---------------------------------------------------------------------------------------------------
 
 /// https://igneum.network/live -> https://igneum.network/api/live; "" when the build carries no live page.
-fn live_api_from(live_page: &str) -> String {
+pub fn live_api_from(live_page: &str) -> String {
     let Some(rest) = live_page.strip_prefix("https://") else { return String::new() };
     let host = rest.split('/').next().unwrap_or("");
     if host.is_empty() { String::new() } else { format!("https://{host}/api/live") }

app/igneum-app/src/platform.rs

@@ -206,6 +206,17 @@ pub fn open_url(url: &str) {
     let _ = Command::new("xdg-open").arg(url).spawn();
 }
 
+/// Shows a file in the system's file browser (the saved block card): Finder with the file selected, Explorer with
+/// the file selected, the folder on other systems.
+pub fn reveal_file(path: &std::path::Path) {
+    #[cfg(target_os = "macos")]
+    let _ = Command::new(tool("open")).arg("-R").arg(path).spawn();
+    #[cfg(windows)]
+    let _ = quiet(&mut Command::new(tool("explorer"))).arg(format!("/select,{}", path.display())).spawn();
+    #[cfg(not(any(target_os = "macos", windows)))]
+    let _ = Command::new("xdg-open").arg(path.parent().unwrap_or(path)).spawn();
+}
+
 /// Keeps the machine awake while the engine runs. macOS: caffeinate tied to this process. Windows: the execution state,
 /// which must be refreshed (call `keep_awake_tick` every minute).
 pub struct KeepAwake {

app/igneum-app/src/powertask.rs

@@ -35,6 +35,46 @@ use std::time::{Duration, Instant};
 pub const TASK_NAME: &str = "Igneum Power Helper";
 /// The helper ends after this long without a new command.
 pub const IDLE_S: u64 = 20 * 60;
+/// The heartbeat file the helper refreshes every poll; an engine judges "the helper runs" by it, never by a flag
+/// of its own (6 October 2026, PC 1: the flag said yes after the helper's idle exit, and commands went to nobody).
+pub const ALIVE_FILE: &str = "helper.alive";
+/// A heartbeat older than this is a dead helper.
+pub const ALIVE_MAX_S: u64 = 4;
+
+/// Writes the heartbeat: the unix time, as text.
+pub fn beat(dir: &Path, now: u64) {
+    let _ = std::fs::write(dir.join(ALIVE_FILE), now.to_string());
+}
+
+/// Reads a heartbeat: is the helper alive at `now`?
+pub fn alive_at(text: &str, now: u64) -> bool {
+    text.trim().parse::<u64>().map(|t| now.saturating_sub(t) <= ALIVE_MAX_S).unwrap_or(false)
+}
+
+/// Is the helper that reads `dir` alive now?
+pub fn alive(dir: &Path) -> bool {
+    std::fs::read_to_string(dir.join(ALIVE_FILE)).map(|t| alive_at(&t, crate::platform::unix_now())).unwrap_or(false)
+}
+
+/// Starts the task unless the helper already runs, then waits for a fresh heartbeat (up to `wait`). The engine
+/// writes a command only after this says Ok: the helper skips what the file held before its start (a stale quit
+/// is not a command), so a command written before the start would be skipped with it (6 October 2026, 17:55:25Z
+/// on PC 1: the first request of the first tune).
+pub fn ensure_running(dir: &Path, wait: Duration) -> Result<(), String> {
+    if alive(dir) {
+        return Ok(());
+    }
+    let _ = std::fs::create_dir_all(dir);
+    start()?;
+    let until = Instant::now() + wait;
+    while Instant::now() < until {
+        std::thread::sleep(Duration::from_millis(250));
+        if alive(dir) {
+            return Ok(());
+        }
+    }
+    Err(format!("the Igneum Power Helper task gave no heartbeat within {} s of its start", wait.as_secs()))
+}
 
 /// One parsed command from cmd.txt.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -79,6 +119,13 @@ pub fn parse_line(line: &str) -> Option<(u64, HelperCmd)> {
     }
 }
 
+/// The commands a helper acts on: the lines added after its start (`skip` = the line count at the start, 0 again
+/// when the file shrank). A stale `quit` or `remove` from an earlier engine is never a command.
+pub fn commands_after(text: &str, skip: usize) -> Vec<(u64, HelperCmd)> {
+    let skip = if text.lines().count() < skip { 0 } else { skip };
+    text.lines().skip(skip).filter_map(parse_line).collect()
+}
+
 /// The nvidia-smi arguments a command becomes (None for the verbs that run nothing).
 pub fn smi_args(dev: &str, c: &HelperCmd) -> Option<Vec<String>> {
     match c {
@@ -195,20 +242,30 @@ pub fn run_helper(dir: &Path) -> i32 {
         }
     };
     log("helper started (scheduled task, elevated)");
-    // a stale file from an earlier run is not a command: only lines after the start count
-    let mut last_seq: u64 = std::fs::read_to_string(&cmd_file).ok().and_then(|t| t.lines().filter_map(parse_line).map(|(s, _)| s).max()).unwrap_or(0);
-    let mut last_text = String::new();
+    beat(dir, crate::platform::unix_now());
+    // a stale file from an earlier run is not a command: only lines ADDED after the start count. 6 October 2026,
+    // PC 1 17:55:55Z: a helper that started after an engine had written `quit` read that line and exited in the
+    // same second, and every later start did the same; so the lines present at the start are skipped whole
+    // (quit and remove included), and a file that shrinks starts the count again
+    let initial = std::fs::read_to_string(&cmd_file).unwrap_or_default();
+    let mut last_seq: u64 = initial.lines().filter_map(parse_line).map(|(s, _)| s).max().unwrap_or(0);
+    let mut skip = initial.lines().count();
+    let mut last_text = initial;
     let mut dev = "0".to_string();
     let mut idle = Instant::now();
     let smi = crate::platform::tool("nvidia-smi");
     loop {
         let text = std::fs::read_to_string(&cmd_file).unwrap_or_default();
         if text != last_text {
+            if text.lines().count() < skip {
+                skip = 0;
+            }
             last_text = text.clone();
-            for (seq, c) in text.lines().filter_map(parse_line) {
+            for (seq, c) in commands_after(&text, skip) {
                 match c {
                     HelperCmd::Quit => {
                         log("quit");
+                        let _ = std::fs::remove_file(dir.join(ALIVE_FILE));
                         return 0;
                     }
                     HelperCmd::Remove => {
@@ -261,8 +318,10 @@ pub fn run_helper(dir: &Path) -> i32 {
         }
         if idle.elapsed() >= Duration::from_secs(IDLE_S) {
             log("idle 20 min: exit (the engine starts the task again when it needs it)");
+            let _ = std::fs::remove_file(dir.join(ALIVE_FILE));
             return 0;
         }
+        beat(dir, crate::platform::unix_now());
         std::thread::sleep(Duration::from_millis(500));
     }
 }
@@ -296,6 +355,15 @@ mod tests {
         assert_eq!(parse_line("quit"), Some((0, HelperCmd::Quit)));
         assert_eq!(parse_line("remove"), Some((0, HelperCmd::Remove)));
         assert_eq!(parse_line("12 reregister"), Some((12, HelperCmd::Reregister)));
+        // a stale quit present at the start is skipped; a quit added later counts; a rewritten (shorter) file counts whole
+        assert_eq!(commands_after("5 dev 0\n6 pl 460\nquit\n", 3), vec![]);
+        assert_eq!(commands_after("5 dev 0\n6 pl 460\nquit\n7 dev 1\n", 3), vec![(7, HelperCmd::Dev("1".into()))]);
+        assert_eq!(commands_after("quit\n", 3), vec![(0, HelperCmd::Quit)]);
+        // the heartbeat: fresh within ALIVE_MAX_S, dead after, dead when unreadable
+        assert!(alive_at("1791309325", 1791309325 + ALIVE_MAX_S));
+        assert!(!alive_at("1791309325", 1791309325 + ALIVE_MAX_S + 1));
+        assert!(!alive_at("", 1791309325));
+        assert!(!alive_at("soon", 1791309325));
         assert_eq!(parse_line("12 reregister C:\\evil.exe"), None, "no path argument: the helper picks the install folder itself");
         assert_eq!(smi_args("0", &HelperCmd::Reregister), None);
         assert!(readback_command().contains("Actions[0].Execute"));

app/igneum-app/src/prover.rs

@@ -135,6 +135,22 @@ struct Tools {
 /// The node's re-derivation boundary (0.3.14, 6 October 2026): the chain block its EVM restarted at after the
 /// bodies below the pruning point were gone (`igneum_getExecStatus.restartNumber`; on a 0.3.13 node the
 /// `startedFrom` text "restart at chain block N"), else 0. The prover never claims work below it (no bodies, no
+/// The exporter's failure line. When the node's export carries the account dump (0.3.14) and the exporter's output
+/// never mentions it, the exporter at `path` predates 0.3.14: it replays the dump's own segment from the restart
+/// state and fails there with "port state root differs" (PC 1, 6 October 2026 18:16Z, block 140,662: the installer
+/// had not replaced igneum-prove-export); the line names the stale binary instead of the misleading root error.
+fn exporter_failure(export_has_dump: bool, out: &str, path: &Path, block: Option<u64>) -> String {
+    let last = out.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("failed");
+    let what = match block {
+        Some(b) => format!("exporter, block {b}"),
+        None => "exporter".to_string(),
+    };
+    if export_has_dump && !out.contains("account dump") {
+        return format!("{what}: stale igneum-prove-export at {}: the node's export carries the account dump and this exporter does not read it (it predates 0.3.14); install this release's exporter there ({last})", path.display());
+    }
+    format!("{what}: {last}")
+}
+
 /// state: unprovable on every node).
 fn exec_boundary(shared: &Shared) -> u64 {
     let st = match evm_rpc(shared, "igneum_getExecStatus", json!([]), Duration::from_secs(5)) {
@@ -499,6 +515,7 @@ fn loop_forever(shared: Arc<Shared>, bin_dir: PathBuf) {
             if paid {
                 submitted.retain(|x| !(x.1 == h && x.2 == s));
                 shared.event("proving", &format!("block {n} shard {s} paid {} IGN", wei as f64 / 1e18));
+                shared.ladder_shard_paid(n, s as u64, wei);
                 set(&shared, |p| {
                     p.paid += 1;
                     p.paid_wei += wei;
@@ -665,7 +682,7 @@ fn loop_forever(shared: Arc<Shared>, bin_dir: PathBuf) {
             let (seq_p, fix_p, res_p) = if t.wsl { (wsl_path(&seq), wsl_path(&fixture), wsl_path(&results)) } else { (seq.display().to_string(), fixture.display().to_string(), results.display().to_string()) };
             let (ok, out) = run_tool(&shared, t, &t.export, &[seq_p, w.number.to_string(), fix_p.clone()], &[], Duration::from_secs(600), &dir.join(format!("export-{}.log", w.number)));
             if !ok || !fixture.exists() {
-                return Err(format!("exporter: {}", out.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("failed")));
+                return Err(exporter_failure(export["preState"].is_array(), &out, &t.export, None));
             }
             set(&shared, |p| p.message = if t.cuda { "proving on the GPU".into() } else { "CPU prover: about five minutes a shard, 30 GB of RAM, paid only when no card proves first".into() });
             let prover_env = if t.cuda { "cuda" } else { "cpu" };
@@ -854,7 +871,7 @@ fn prove_segment(shared: &Shared, t: &Tools, seg: &crate::segments::SegmentWork,
         let fixture = dir.join(format!("block-{b}.json"));
         let (ok, out) = run_tool(shared, t, &t.export, &[as_host_path(&seq), b.to_string(), as_host_path(&fixture)], &[], Duration::from_secs(600), &dir.join(format!("export-{b}.log")));
         if !ok || !fixture.exists() {
-            return Err(format!("exporter, block {b}: {}", out.lines().rev().find(|l| !l.trim().is_empty()).unwrap_or("failed")));
+            return Err(exporter_failure(export["preState"].is_array(), &out, &t.export, Some(b)));
         }
         fixtures.push(as_host_path(&fixture));
     }
@@ -1092,6 +1109,21 @@ pub fn setup(shared: &Shared) -> Result<Value, String> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn a_stale_exporter_is_named_when_the_export_carries_the_dump() {
+        let p = Path::new("C:/x/igneum-prove-export.exe");
+        let old_out = "Error: segment 140661: port state root 0xe45c differs from the node's 0xddd7; the port is not the node's executor, stop\n";
+        let line = exporter_failure(true, old_out, p, Some(140662));
+        assert!(line.contains("stale igneum-prove-export at C:/x/igneum-prove-export.exe"), "{line}");
+        assert!(line.starts_with("exporter, block 140662:"));
+        // the 0.3.14 exporter read the dump and failed later: the real line, not the stale one
+        let new_out = "account dump: 79 accounts after chain block 140661, state root 0x1 (equals the node's)\nError: segment 140662: port state root 0x2 differs from the node's 0x3\n";
+        let line = exporter_failure(true, new_out, p, None);
+        assert_eq!(line, "exporter: Error: segment 140662: port state root 0x2 differs from the node's 0x3");
+        // an export without a dump (an older node): never the stale line
+        assert_eq!(exporter_failure(false, old_out, p, None), format!("exporter: {}", old_out.trim()));
+    }
+
     #[test]
     fn pinned_ids_come_out_of_the_hosts_id_line() {
         let out = "RESULT id: pinned guests: shard program id 0x2b1a81cb413236cf063077b46ed3111628f6c41036bcf6e23ee4cbbf5679ef7a (2832504 bytes, sha256 0x150f4c05a2951fc5) aggregator id 0x474678f35f7545db28055d5e5bbc308231d84a5a072202087a2a8d5b09123896 (319744 bytes), pinned 2026-10-05T16:20:38Z on Darwin, SP1 5.0 circuit v5\n";

app/igneum-app/src/server.rs

@@ -12,6 +12,9 @@ const INDEX: &str = include_str!("../ui/index.html");
 const CSS: &str = include_str!("../ui/app.css");
 const JS: &str = include_str!("../ui/app.js");
 const MARK: &str = include_str!("../ui/mark.svg");
+const DAG_JS: &str = include_str!("../ui/live-dag.js");
+/// the renderer pack's proof visual (EMBER 02, the site lane's byte-identical copy; miner-ui-5)
+const PROOF_JS: &str = include_str!("../ui/proof-core.js");
 const COIN: &[u8] = include_bytes!("../../../brand/igneum-coin-1024.png");
 const FONT_MONO_400: &[u8] = include_bytes!("../ui/fonts/IBMPlexMono-400.woff2");
 const FONT_MONO_500: &[u8] = include_bytes!("../ui/fonts/IBMPlexMono-500.woff2");
@@ -138,6 +141,15 @@ fn json_resp(stream: &mut TcpStream, status: u16, v: Value) {
     respond(stream, status, "application/json; charset=utf-8", v.to_string().as_bytes(), false);
 }
 
+/// Where a screenshot lands: `<data root>/shots/igneum-<name>-<unix>.png`, the name reduced to [a-z0-9-] (at most
+/// 24 characters, "shot" when empty) so a caller cannot steer the host outside the folder.
+pub fn shot_path(data_root: &std::path::Path, name: &str, unix: u64) -> std::path::PathBuf {
+    let safe: String = name.chars().filter(|c| c.is_ascii_alphanumeric() || *c == '-').map(|c| c.to_ascii_lowercase()).take(24).collect();
+    let safe = if safe.is_empty() { "shot".to_string() } else { safe };
+    data_root.join("shots").join(format!("igneum-{safe}-{unix}.png"))
+}
+
+
 fn query_param(q: &str, key: &str) -> Option<String> {
     q.split('&').find_map(|kv| {
         let (k, v) = kv.split_once('=')?;
@@ -160,11 +172,31 @@ fn handle(mut stream: TcpStream, shared: Arc<Shared>) {
         return;
     };
     let rest = if rest.is_empty() { "/" } else { rest };
+    // ui-ota (src/uiota.rs): an active interface bundle serves its files in place of the embedded ones; the names are
+    // fixed (uiota::SERVED), nothing else is read from the folder; a file the bundle lacks falls back to the embedded one
+    if req.method == "GET" {
+        let rel = if rest == "/" { "index.html" } else { rest.trim_start_matches('/') };
+        if crate::uiota::SERVED.contains(&rel) {
+            if let Some(dir) = shared.ui_dir() {
+                if let Ok(bytes) = std::fs::read(dir.join(rel)) {
+                    if rel == "index.html" {
+                        let v = std::fs::read_to_string(dir.join("VERSION")).unwrap_or_default().trim().to_string();
+                        shared.send(Cmd::UiPageLoaded(v));
+                    }
+                    respond(&mut stream, 200, crate::uiota::content_type(rel), &bytes, rel.starts_with("fonts/"));
+                    return;
+                }
+            }
+        }
+    }
     match (req.method.as_str(), rest) {
         ("GET", "/") | ("GET", "/index.html") => respond(&mut stream, 200, "text/html; charset=utf-8", INDEX.as_bytes(), false),
+        ("GET", "/VERSION") => respond(&mut stream, 200, "text/plain; charset=utf-8", crate::uiota::EMBEDDED_VERSION.as_bytes(), false),
         ("GET", "/app.css") => respond(&mut stream, 200, "text/css; charset=utf-8", CSS.as_bytes(), false),
         ("GET", "/app.js") => respond(&mut stream, 200, "application/javascript; charset=utf-8", JS.as_bytes(), false),
         ("GET", "/mark.svg") => respond(&mut stream, 200, "image/svg+xml", MARK.as_bytes(), true),
+        ("GET", "/live-dag.js") => respond(&mut stream, 200, "application/javascript; charset=utf-8", DAG_JS.as_bytes(), false),
+        ("GET", "/proof-core.js") => respond(&mut stream, 200, "application/javascript; charset=utf-8", PROOF_JS.as_bytes(), false),
         ("GET", "/coin.png") => respond(&mut stream, 200, "image/png", COIN, true),
         ("GET", "/fonts/IBMPlexMono-400.woff2") => respond(&mut stream, 200, "font/woff2", FONT_MONO_400, true),
         ("GET", "/fonts/IBMPlexMono-500.woff2") => respond(&mut stream, 200, "font/woff2", FONT_MONO_500, true),
@@ -178,6 +210,20 @@ fn handle(mut stream: TcpStream, shared: Arc<Shared>) {
             let v = shared.state_json();
             json_resp(&mut stream, 200, v);
         }
+        // the chain scene's feed (src/live.rs): the observer's /api/live with this machine's lane as "you", cached 2 s
+        ("GET", "/api/live") => {
+            let window = query_param(&req.query, "window").and_then(|s| s.parse().ok()).unwrap_or(120u32);
+            let live_api = std::env::var("IGNEUM_APP_LIVE_API").unwrap_or_else(|_| crate::ota::live_api_from(&shared.packaged.live_page));
+            let ids: std::collections::HashSet<String> = shared.state.lock().unwrap().mining.cards.iter().flat_map(|c| c.ids.iter().cloned()).collect();
+            json_resp(&mut stream, 200, crate::live::fetch(&live_api, window, &ids));
+        }
+        // miner-ui-5: the ladder's chain facts (src/chainfacts.rs): the node's getFinalityWeights through the local
+        // node when it answers igneum_getFinalityWeights, else the observer's relay; cached 10 s
+        ("GET", "/api/ladder") => {
+            let live_api = std::env::var("IGNEUM_APP_LIVE_API").unwrap_or_else(|_| crate::ota::live_api_from(&shared.packaged.live_page));
+            let ids: Vec<String> = shared.state.lock().unwrap().mining.cards.iter().flat_map(|c| c.ids.iter().cloned()).collect();
+            json_resp(&mut stream, 200, crate::chainfacts::fetch(shared.runtime.evm_port(), &live_api, &ids));
+        }
         ("GET", "/api/log") => {
             let after = query_param(&req.query, "after").and_then(|s| s.parse().ok()).unwrap_or(0u64);
             let limit = query_param(&req.query, "limit").and_then(|s| s.parse().ok()).unwrap_or(400usize).min(2000);
@@ -256,6 +302,14 @@ fn api_post(shared: &Arc<Shared>, path: &str, body: Value) -> Result<Value, Stri
             let goal = body.get("goal").and_then(|v| v.as_str()).map(|g| crate::ember::Goal::parse(g).name().to_string());
             let price = body.get("price_pence").and_then(|v| v.as_f64()).filter(|p| (0.0..=500.0).contains(p));
             let climb = body.get("climb").and_then(|v| v.as_bool());
+            // with "key": that card's goal override ("" or "global" clears it); without: the global goal
+            let key = body.get("key").and_then(|v| v.as_str()).map(|k| k.to_string());
+            if let Some(k) = key {
+                let g = body.get("goal").and_then(|v| v.as_str()).unwrap_or("");
+                let g = if g.is_empty() || g == "global" { String::new() } else { crate::ember::Goal::parse(g).name().to_string() };
+                shared.send(Cmd::TuneCardGoal(k, g));
+                return Ok(json!({ "ok": true }));
+            }
             shared.send(Cmd::TuneGoal(goal, price, climb));
             Ok(json!({ "ok": true }))
         }
@@ -267,7 +321,8 @@ fn api_post(shared: &Arc<Shared>, path: &str, body: Value) -> Result<Value, Stri
             let display_name = s("display_name");
             let dev_fee = body.get("dev_fee").and_then(|v| v.as_bool());
             let proof_verify_trust = body.get("proof_verify_trust").and_then(|v| v.as_bool());
-            shared.apply_settings(identities, vote, login, address.as_deref(), display_name.as_deref(), dev_fee, proof_verify_trust)
+            let profile_public = body.get("profile_public").and_then(|v| v.as_bool());
+            shared.apply_settings(identities, vote, login, address.as_deref(), display_name.as_deref(), dev_fee, proof_verify_trust, profile_public)
         }
         "/api/prove" => shared.set_prove(body.get("on").and_then(|v| v.as_bool()).unwrap_or(false)),
         "/api/prove/setup" => crate::prover::setup(shared),
@@ -279,6 +334,17 @@ fn api_post(shared: &Arc<Shared>, path: &str, body: Value) -> Result<Value, Stri
             shared.send(Cmd::InstallUpdate);
             Ok(json!({ "ok": true }))
         }
+        "/api/ui/health" => {
+            // ui-ota: the page's first-paint ping (no error) or the error it caught before it (src/uiota.rs)
+            let err = body.get("error").and_then(|v| v.as_str()).filter(|e| !e.is_empty()).map(|e| e.to_string());
+            shared.send(Cmd::UiHealth(err));
+            Ok(json!({ "ok": true }))
+        }
+        "/api/ui/builtin" => {
+            let on = body.get("on").and_then(|v| v.as_bool()).ok_or("on missing")?;
+            shared.send(Cmd::UiBuiltin(on));
+            Ok(json!({ "ok": true }))
+        }
         "/api/update/auto" => {
             let on = body.get("on").and_then(|v| v.as_bool()).ok_or("on missing")?;
             shared.send(Cmd::AutoUpdate(on));
@@ -351,6 +417,29 @@ fn api_post(shared: &Arc<Shared>, path: &str, body: Value) -> Result<Value, Stri
             shared.send(Cmd::ClockCheck);
             Ok(json!({ "ok": true }))
         }
+        // Miner UI 4 (b): a screenshot from the machine itself. The host (app/mac, app/windows) owns the window, so the
+        // engine asks it over the host protocol ("SHOT <path>", beside URL, STATE and EXIT) and the host writes a PNG of
+        // what it shows to that path under <data root>/shots/, where a collect job's glob "shots/*.png" picks it up.
+        // Read-only: nothing about mining changes. A caller without a host (a bare engine) gets the path and no file.
+        // miner-ui-5: the block card's PNG, drawn by the page on a canvas (no network call), written under
+        // <data root>/cards/ and the folder opened for the user. The body is {name, png: "data:image/png;base64,..."}.
+        "/api/card" => {
+            let name = body.get("name").and_then(|v| v.as_str()).unwrap_or("block");
+            let png = body.get("png").and_then(|v| v.as_str()).ok_or("png missing")?;
+            let bytes = crate::card::decode_data_url(png).ok_or("the png is not a base64 data URL")?;
+            let path = crate::card::card_path(&crate::platform::data_root(), name, crate::platform::unix_now());
+            if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
+            std::fs::write(&path, &bytes).map_err(|e| format!("could not write the card: {e}"))?;
+            if body.get("reveal").and_then(|v| v.as_bool()).unwrap_or(true) { crate::platform::reveal_file(&path); }
+            Ok(json!({ "ok": true, "path": path.display().to_string(), "bytes": bytes.len() }))
+        }
+        "/api/shot" => {
+            let name = body.get("name").and_then(|v| v.as_str()).unwrap_or("");
+            let path = shot_path(&crate::platform::data_root(), name, crate::platform::unix_now());
+            if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
+            println!("SHOT {}", path.display());
+            Ok(json!({ "ok": true, "path": path.display().to_string(), "note": "the window host writes the PNG within a few seconds; a bare engine without a host writes nothing" }))
+        }
         "/api/quit" => {
             // the caller is on 127.0.0.1 and holds the token: the installer, the OTA apply, a script that read app.url
             shared.send(Cmd::Quit("POST /api/quit (a local caller with the token: the installer, the OTA apply, or a script that read app.url)"));
@@ -359,3 +448,17 @@ fn api_post(shared: &Arc<Shared>, path: &str, body: Value) -> Result<Value, Stri
         _ => Err("unknown api".into()),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn a_shot_lands_under_the_data_root_with_a_safe_name() {
+        let root = std::path::Path::new("/tmp/igneum-data");
+        assert_eq!(shot_path(root, "overview", 1791327000), std::path::PathBuf::from("/tmp/igneum-data/shots/igneum-overview-1791327000.png"));
+        assert_eq!(shot_path(root, "../../etc/passwd", 1), std::path::PathBuf::from("/tmp/igneum-data/shots/igneum-etcpasswd-1.png"));
+        assert_eq!(shot_path(root, "", 2), std::path::PathBuf::from("/tmp/igneum-data/shots/igneum-shot-2.png"));
+        assert_eq!(shot_path(root, "Cards Light!", 3), std::path::PathBuf::from("/tmp/igneum-data/shots/igneum-cardslight-3.png"));
+        assert!(shot_path(root, &"x".repeat(80), 4).file_name().unwrap().to_string_lossy().len() < 48);
+    }
+}

app/igneum-app/src/state.rs

@@ -21,6 +21,29 @@ pub struct NodeState {
     pub version: String,
     pub last_reading_age_s: f64,
     pub message: String,
+    /// N4 (6 October 2026, the frozen tip): seconds since the sink block's header time, from the watch line's
+    /// tip_age_s (the node lane, ca3-v4-0316); -1 until the node reports it. "synced" needs it at or under 120.
+    pub tip_age_s: f64,
+    /// whose node this is (publish 2's read-back, 6 October 2026): "app" (started by this app), "external" (another
+    /// node on this machine holds the ports; used after a check), "none" (the ports are taken by a node on other rules
+    /// or another network, so no node is read), "" before the first start
+    pub source: String,
+    /// for an external node: match | mismatch | unknown (an older node that cannot answer the check)
+    pub rules_check: String,
+    /// the one line that says what happened at the ports, kept for the Node details
+    pub port_note: String,
+    /// where consensus_digest came from: "rpc" (igneum_getNodeInfo), "log" (the node's own stdout line), ""
+    pub digest_source: String,
+    /// which node this app reads: "own" (it started one), "external" (another node on this machine holds the ports),
+    /// "none" (the ports are taken by a node it refuses), "" before the first decision. Re-decided when the other
+    /// node goes away (7 October 2026): after 60 s the app starts its own on the freed ports.
+    pub mode: String,
+    /// why the mode is what it is, one line
+    pub mode_reason: String,
+    /// why the node is not "synced", in plain words ("" when synced): "behind" | "no peers" | "syncing" | "frozen"
+    pub sync_cause: String,
+    /// the miner's stall exits (code 45, "STALLED") since the node last started; the second one restarts the node
+    pub stall_exits: u32,
     /// a consensus switch the signed manifest announced (difficulty v2 activation DAA); 0 = none
     pub consensus_switch_daa: u64,
     pub override_restart_wait: String,
@@ -126,6 +149,9 @@ pub struct CardState {
     pub tune_clock_mhz: u32,   // the clock cap the last tune chose (0 = unlocked)
     pub tune_source: String,   // full | confirm | baseline
     pub tune_line: String,     // "Tuned: 122.3 MH/s at 290 W (0.422 MH/W)" once tuned
+    pub tune_goal: String,     // this card's goal override (efficiency | balanced | rate); "" = the global goal
+    pub tune_before_watts: f64, // the untuned point of the last full plan (step 0); 0 = never measured
+    pub tune_before_mhs: f64,
     // a tune in progress on this card, by this engine or by a measurement engine posting /api/tune-progress
     // (the project lead, 6 October 2026: "don't we need to show in the app that tuning is in progress?")
     pub tune_step: u32,
@@ -304,6 +330,34 @@ pub struct SettingsState {
     pub dev_fee: bool,
     /// devnet only: the node trusts proof records without a verifier (`IGNEUM_PROOF_VERIFY=trust`)
     pub proof_verify_trust: bool,
+    /// miner-ui-5: the public address profile opt-in (settings.profile_public)
+    pub profile_public: bool,
+    /// ui-ota: "Use the built-in interface" (settings.ui_builtin)
+    pub ui_builtin: bool,
+}
+
+/// The interface over the air (src/uiota.rs): what serves, from where, since when; Settings > Interface.
+#[derive(Clone, Serialize, Default)]
+pub struct UiState {
+    /// the version compiled into this engine (ui/VERSION)
+    pub embedded_version: String,
+    /// the version the server serves now (the bundle's, or the embedded one)
+    pub active_version: String,
+    /// embedded | ota
+    pub source: String,
+    /// unix s the active bundle was swapped in (0 for the embedded interface)
+    pub installed_at: f64,
+    /// the page confirmed the active bundle with its health ping (always true for the embedded interface)
+    pub confirmed: bool,
+    /// the version the manifest publishes now ("" when the channel is withdrawn)
+    pub published_version: String,
+    pub busy: bool,
+    pub error: String,
+    /// versions refused here (never applied again)
+    pub bad: Vec<String>,
+    pub builtin: bool,
+    /// why the published version is not applied, when it is not
+    pub note: String,
 }
 
 /// One remote job this machine ran (the ledger entry), for the Settings history and the last-job strip.
@@ -415,12 +469,15 @@ pub struct State {
     pub settings: SettingsState,
     pub dev_fee: DevFeeState,
     pub update: UpdateState,
+    pub ui: UiState,
     pub jobs: JobsState,
     pub events: Vec<Event>,
     pub uptime_s: u64,
     pub now: f64,
     pub quitting: bool,
     pub live_page: String,
+    /// miner-ui-5: this machine's own ladder record (src/ladder.rs), summarised at `now`
+    pub ladder: crate::ladder::LadderState,
 }
 
 /// Ring buffers behind the state: events (newest first in the JSON) and the log drawer.

app/igneum-app/src/uiota.rs

@@ -0,0 +1,533 @@
+//! Interface over the air (docs/plans/ui-ota.md, 7 October 2026): the dashboard (app/igneum-app/ui, embedded in the
+//! engine binary) can be replaced by a signed bundle from the manifest's `ui` channel without a new app version.
+//!
+//! The flow, driven from the updater's hourly manifest (src/ota.rs hands the parsed `ui` entry over):
+//!   decide: the entry is ignored when its min_engine is newer than this engine, when its version is the active
+//!           one or the embedded one, when it was marked bad before, or when the miner chose the built-in interface
+//!   -> download (curl to <app data>/ui/<version>.tar.gz, size and sha256 against the manifest, then the entry's own
+//!      Ed25519 signature with the release key compiled into src/manifest.rs; the manifest's signature covered it too)
+//!   -> unpack with the system tar into <app data>/ui/<version>.new, index.html, app.js and app.css must be there,
+//!      rename to <app data>/ui/<version>
+//!   -> swap: <app data>/ui/current.json names the version (written to .tmp and renamed: atomic); the server reads
+//!      the pointer through Shared and serves the bundle's files in place of the embedded ones at the next page load;
+//!      the open page sees state.ui.active_version change and reloads itself when idle
+//!   -> confirm: the first page load from a new bundle starts a 10 s wait for the page's health ping
+//!      (POST /api/ui/health after its first paint; a JS error on first paint posts the error instead); no ping, an
+//!      error, or a bundle that fails to unpack rolls back to the embedded interface and marks the version bad
+//!      (<app data>/ui/bad.json): it is never applied again
+//! The kill switch is the manifest without a `ui` object: the engine falls back to the embedded interface on the
+//! next check. Same origin, no remote script: the bundle is served from 127.0.0.1 by this engine like the embedded
+//! files, and the signature is the only trust.
+
+use crate::engine::{Cmd, Shared};
+use crate::manifest::{self, UiEntry};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+/// The page's health ping must arrive this long after the first load of a new bundle.
+pub const HEALTH_WAIT_S: u64 = 10;
+/// The version of the interface compiled into this engine (app/igneum-app/ui/VERSION).
+pub const EMBEDDED_VERSION: &str = include_str!("../ui/VERSION");
+/// The files a bundle may serve: fixed names, nothing else is read from the bundle folder.
+pub const SERVED: [&str; 15] = ["index.html", "app.css", "app.js", "mark.svg", "live-dag.js", "proof-core.js", "VERSION", "fonts/IBMPlexMono-400.woff2", "fonts/IBMPlexMono-500.woff2", "fonts/IBMPlexSans-400.woff2", "fonts/IBMPlexSans-500.woff2", "fonts/IBMPlexSans-600.woff2", "fonts/Unbounded-500.woff2", "fonts/Unbounded-700.woff2", "fonts/Unbounded-900.woff2"];
+/// What a bundle must carry to be swapped in.
+const REQUIRED: [&str; 3] = ["index.html", "app.js", "app.css"];
+
+pub fn embedded_version() -> &'static str {
+    EMBEDDED_VERSION.trim()
+}
+
+pub enum Event {
+    /// the download, the checks and the unpack finished: the bundle folder, or why not (with the version)
+    Installed(String, Result<PathBuf, String>),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Decision {
+    Apply,
+    Skip(String),
+}
+
+/// Whether a published entry is for this engine now (pure; the tests cover every branch).
+pub fn decide(e: &UiEntry, engine: &str, embedded: &str, active: Option<&str>, bad: &[String], builtin: bool) -> Decision {
+    if builtin {
+        return Decision::Skip("the built-in interface is chosen in Settings".into());
+    }
+    if manifest::newer(&e.min_engine, engine) {
+        return Decision::Skip(format!("interface {} needs engine {} or newer (this is {engine})", e.version, e.min_engine));
+    }
+    if bad.iter().any(|b| b == &e.version) {
+        return Decision::Skip(format!("interface {} failed here before and is not tried again", e.version));
+    }
+    if active == Some(e.version.as_str()) {
+        return Decision::Skip(format!("interface {} is active", e.version));
+    }
+    if e.version == embedded {
+        return Decision::Skip(format!("interface {} is the built-in one", e.version));
+    }
+    Decision::Apply
+}
+
+/// The pointer file: which bundle the server serves ("embedded" or a version) and when it was swapped in.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Current {
+    pub version: String,
+    pub installed_at: u64,
+    /// the page confirmed this bundle with a health ping
+    pub confirmed: bool,
+}
+
+fn read_current(dir: &Path) -> Current {
+    let v: serde_json::Value = std::fs::read_to_string(dir.join("current.json")).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(serde_json::Value::Null);
+    Current { version: v.get("version").and_then(|x| x.as_str()).unwrap_or("embedded").to_string(), installed_at: v.get("installed_at").and_then(|x| x.as_u64()).unwrap_or(0), confirmed: v.get("confirmed").and_then(|x| x.as_bool()).unwrap_or(false) }
+}
+
+/// Writes the pointer atomically (the .tmp then the rename).
+pub fn write_current(dir: &Path, c: &Current) -> Result<(), String> {
+    let _ = std::fs::create_dir_all(dir);
+    let tmp = dir.join("current.json.tmp");
+    std::fs::write(&tmp, serde_json::json!({ "version": c.version, "installed_at": c.installed_at, "confirmed": c.confirmed }).to_string()).map_err(|e| e.to_string())?;
+    std::fs::rename(&tmp, dir.join("current.json")).map_err(|e| e.to_string())
+}
+
+fn read_bad(dir: &Path) -> Vec<String> {
+    std::fs::read_to_string(dir.join("bad.json")).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or_default()
+}
+
+fn write_bad(dir: &Path, bad: &[String]) {
+    let _ = std::fs::write(dir.join("bad.json"), serde_json::to_string(bad).unwrap_or_default());
+}
+
+/// The bundle folder for a version, if it holds what the server needs.
+pub fn bundle_dir(dir: &Path, version: &str) -> Option<PathBuf> {
+    if version == "embedded" || version.is_empty() {
+        return None;
+    }
+    let d = dir.join(version);
+    if REQUIRED.iter().all(|f| d.join(f).is_file()) { Some(d) } else { None }
+}
+
+/// Size, sha256 and the entry's own signature, then the unpack into <dir>/<version>: the folder on success.
+/// `pub_hex` is the release key (manifest::OTA_PUBLIC_KEY_HEX in the engine; the tests pass their own).
+pub fn install_bundle(e: &UiEntry, file: &Path, dir: &Path, pub_hex: &str) -> Result<PathBuf, String> {
+    let size = std::fs::metadata(file).map(|m| m.len()).map_err(|er| format!("{}: {er}", file.display()))?;
+    if size != e.size {
+        return Err(format!("interface {}: the download is {size} bytes, the manifest says {}", e.version, e.size));
+    }
+    let sum = manifest::sha256_file(file).map_err(|er| er.to_string())?;
+    if sum != e.sha256 {
+        return Err(format!("interface {}: sha256 mismatch", e.version));
+    }
+    manifest::verify_ui_entry(e, pub_hex).map_err(|er| format!("interface {}: {er}", e.version))?;
+    let fresh = dir.join(format!("{}.new", e.version));
+    let _ = std::fs::remove_dir_all(&fresh);
+    std::fs::create_dir_all(&fresh).map_err(|er| er.to_string())?;
+    let mut c = std::process::Command::new(crate::platform::tool("tar"));
+    c.args(["-xzf", &file.display().to_string(), "-C", &fresh.display().to_string()]);
+    let out = crate::detect::run_timeout(&mut c, None, Duration::from_secs(60)).ok_or("tar is not available")?;
+    // a bundle packed with a top-level folder: take it
+    let root = if REQUIRED.iter().all(|f| fresh.join(f).is_file()) {
+        fresh.clone()
+    } else {
+        let inner = std::fs::read_dir(&fresh).ok().into_iter().flatten().filter_map(|d| d.ok()).map(|d| d.path()).find(|p| p.is_dir() && REQUIRED.iter().all(|f| p.join(f).is_file()));
+        match inner {
+            Some(p) => p,
+            None => {
+                let _ = std::fs::remove_dir_all(&fresh);
+                return Err(format!("interface {}: the bundle has no index.html, app.js and app.css ({})", e.version, out.lines().last().unwrap_or("tar said nothing")));
+            }
+        }
+    };
+    let dest = dir.join(&e.version);
+    let _ = std::fs::remove_dir_all(&dest);
+    std::fs::rename(&root, &dest).map_err(|er| format!("interface {}: {er}", e.version))?;
+    let _ = std::fs::remove_dir_all(&fresh);
+    // the bundle's own VERSION must agree with the manifest (a renamed bundle is refused)
+    let v = std::fs::read_to_string(dest.join("VERSION")).unwrap_or_default();
+    if v.trim() != e.version {
+        let _ = std::fs::remove_dir_all(&dest);
+        return Err(format!("interface {}: the bundle's VERSION file says '{}'", e.version, v.trim()));
+    }
+    Ok(dest)
+}
+
+/// The engine's side: what is active, what is pending, the health wait, the rollback.
+pub struct UiOta {
+    dir: PathBuf,
+    current: Current,
+    bad: Vec<String>,
+    builtin: bool,
+    busy: bool,
+    /// the manifest entry seen last (for the Settings line and the retry after an error)
+    entry: Option<UiEntry>,
+    /// a bundle served to a page and not yet confirmed: (version, when the page loaded)
+    waiting: Option<(String, Instant)>,
+    error: String,
+    /// the whole download thread's last reason, kept for the state
+    last_skip: String,
+    health_wait: Duration,
+}
+
+impl UiOta {
+    pub fn new(shared: &Arc<Shared>) -> UiOta {
+        let dir = shared.runtime.app_dir.join("ui");
+        let _ = std::fs::create_dir_all(&dir);
+        let builtin = shared.settings.lock().unwrap().ui_builtin;
+        let mut u = UiOta { dir: dir.clone(), current: read_current(&dir), bad: read_bad(&dir), builtin, busy: false, entry: None, waiting: None, error: String::new(), last_skip: String::new(), health_wait: Duration::from_secs(HEALTH_WAIT_S) };
+        // a pointer to a folder that is not there (a cleaned app data folder) falls back without a word
+        if bundle_dir(&dir, &u.current.version).is_none() && u.current.version != "embedded" {
+            shared.log(&format!("ui: the pointer names interface {} but its folder is gone; the built-in interface serves", u.current.version));
+            u.current = Current { version: "embedded".into(), installed_at: 0, confirmed: true };
+            let _ = write_current(&dir, &u.current);
+        }
+        u.apply_pointer(shared);
+        if u.current.version != "embedded" {
+            shared.log(&format!("ui bundle {} active (installed {}){}", u.current.version, u.current.installed_at, if u.builtin { ", but the built-in interface is chosen" } else { "" }));
+        }
+        u.publish(shared);
+        u
+    }
+
+    /// What the server serves: the bundle folder, or None for the embedded files.
+    fn apply_pointer(&self, shared: &Arc<Shared>) {
+        let d = if self.builtin { None } else { bundle_dir(&self.dir, &self.current.version) };
+        shared.set_ui_dir(d);
+    }
+
+    pub fn active_version(&self) -> &str {
+        &self.current.version
+    }
+
+    /// Called with every verified manifest: the `ui` entry or None (the kill switch).
+    pub fn consider(&mut self, shared: &Arc<Shared>, entry: Option<&UiEntry>, engine: &str) {
+        let Some(e) = entry else {
+            self.entry = None;
+            if self.current.version != "embedded" {
+                shared.event("info", &format!("the interface channel was withdrawn; the built-in interface {} serves again", embedded_version()));
+                shared.log(&format!("ui: no ui object in the manifest; interface {} retired", self.current.version));
+                self.set_current(shared, Current { version: "embedded".into(), installed_at: crate::platform::unix_now(), confirmed: true });
+            }
+            self.publish(shared);
+            return;
+        };
+        self.entry = Some(e.clone());
+        if self.busy {
+            return;
+        }
+        match decide(e, engine, embedded_version(), Some(&self.current.version), &self.bad, self.builtin) {
+            Decision::Skip(why) => {
+                if why != self.last_skip {
+                    shared.log(&format!("ui: {why}"));
+                    self.last_skip = why;
+                }
+            }
+            Decision::Apply => {
+                self.last_skip = String::new();
+                self.busy = true;
+                self.error = String::new();
+                shared.event("info", &format!("interface {} is published: downloading ({} KB)", e.version, e.size / 1000));
+                let e2 = e.clone();
+                let dir = self.dir.clone();
+                let shared2 = shared.clone();
+                std::thread::spawn(move || {
+                    let r = download_and_install(&e2, &dir);
+                    shared2.send(Cmd::UiOta(Event::Installed(e2.version.clone(), r)));
+                });
+            }
+        }
+        self.publish(shared);
+    }
+
+    pub fn event(&mut self, shared: &Arc<Shared>, ev: Event) {
+        self.busy = false;
+        match ev {
+            Event::Installed(version, Ok(_dir)) => {
+                shared.event("ok", &format!("interface {version} installed; the window takes it at its next load"));
+                self.set_current(shared, Current { version: version.clone(), installed_at: crate::platform::unix_now(), confirmed: false });
+                shared.log(&format!("ui bundle {version} active (installed {}), awaiting the page's health ping", self.current.installed_at));
+            }
+            Event::Installed(version, Err(e)) => {
+                self.mark_bad(shared, &version, &e);
+            }
+        }
+        self.publish(shared);
+    }
+
+    fn set_current(&mut self, shared: &Arc<Shared>, c: Current) {
+        self.current = c;
+        if let Err(e) = write_current(&self.dir, &self.current) {
+            shared.log(&format!("ui: could not write the pointer: {e}"));
+        }
+        self.waiting = None;
+        self.apply_pointer(shared);
+    }
+
+    fn mark_bad(&mut self, shared: &Arc<Shared>, version: &str, why: &str) {
+        if !self.bad.iter().any(|b| b == version) {
+            self.bad.push(version.to_string());
+            write_bad(&self.dir, &self.bad);
+        }
+        self.error = why.to_string();
+        shared.event("error", &format!("interface {version} was refused: {why}. The built-in interface serves"));
+        shared.log(&format!("ui: {version} marked bad: {why}"));
+        if self.current.version == version {
+            self.set_current(shared, Current { version: "embedded".into(), installed_at: crate::platform::unix_now(), confirmed: true });
+        }
+    }
+
+    /// The server served index.html from a bundle: an unconfirmed one starts the health wait.
+    pub fn page_loaded(&mut self, version: &str, now: Instant) {
+        if version == self.current.version && !self.current.confirmed && self.waiting.is_none() {
+            self.waiting = Some((version.to_string(), now));
+        }
+    }
+
+    /// The page's ping after its first paint, or the error it caught before it.
+    pub fn health(&mut self, shared: &Arc<Shared>, error: Option<&str>) {
+        let Some((version, _)) = self.waiting.clone() else { return };
+        match error {
+            None => {
+                self.waiting = None;
+                self.current.confirmed = true;
+                let _ = write_current(&self.dir, &self.current);
+                shared.log(&format!("ui bundle {version} confirmed by the page"));
+                self.publish(shared);
+            }
+            Some(e) => {
+                self.mark_bad(shared, &version, &format!("a script error on first paint: {}", e.chars().take(200).collect::<String>()));
+                self.publish(shared);
+            }
+        }
+    }
+
+    /// The wait ran out: the page never confirmed the bundle.
+    pub fn tick(&mut self, shared: &Arc<Shared>, now: Instant) {
+        if let Some((version, since)) = self.waiting.clone() {
+            if now.duration_since(since) >= self.health_wait {
+                self.mark_bad(shared, &version, &format!("the page did not answer within {} s of loading it", self.health_wait.as_secs()));
+                self.publish(shared);
+            }
+        }
+    }
+
+    pub fn set_builtin(&mut self, shared: &Arc<Shared>, on: bool) {
+        self.builtin = on;
+        {
+            let mut s = shared.settings.lock().unwrap();
+            s.ui_builtin = on;
+            s.save(&shared.settings_path);
+        }
+        shared.state.lock().unwrap().settings.ui_builtin = on;
+        self.waiting = None;
+        self.apply_pointer(shared);
+        shared.event("info", if on { "the built-in interface serves from the next page load" } else { "the over-the-air interface serves again when one is active" });
+        self.publish(shared);
+    }
+
+    /// Settings > Interface: what serves, from where, since when.
+    pub fn publish(&self, shared: &Arc<Shared>) {
+        let mut st = shared.state.lock().unwrap();
+        let u = &mut st.ui;
+        let ota_active = !self.builtin && bundle_dir(&self.dir, &self.current.version).is_some();
+        u.embedded_version = embedded_version().into();
+        u.active_version = if ota_active { self.current.version.clone() } else { embedded_version().into() };
+        u.source = if ota_active { "ota".into() } else { "embedded".into() };
+        u.installed_at = if ota_active { self.current.installed_at as f64 } else { 0.0 };
+        u.confirmed = !ota_active || self.current.confirmed;
+        u.published_version = self.entry.as_ref().map(|e| e.version.clone()).unwrap_or_default();
+        u.busy = self.busy;
+        u.error = self.error.clone();
+        u.bad = self.bad.clone();
+        u.builtin = self.builtin;
+        u.note = self.last_skip.clone();
+    }
+}
+
+/// The download thread: curl with resume into <dir>/<version>.tar.gz, then install_bundle.
+fn download_and_install(e: &UiEntry, dir: &Path) -> Result<PathBuf, String> {
+    let _ = std::fs::create_dir_all(dir);
+    let file = dir.join(format!("{}.tar.gz", e.version));
+    let part = dir.join(format!("{}.tar.gz.part", e.version));
+    let mut c = std::process::Command::new(crate::platform::tool("curl"));
+    c.args(["-fsSL", "--max-time", "300", "-C", "-", "-o", &part.display().to_string(), &e.url]);
+    let out = crate::detect::run_timeout(&mut c, None, Duration::from_secs(320)).ok_or("curl is not available")?;
+    let t = out.trim();
+    if !t.is_empty() && !part.is_file() {
+        return Err(format!("interface {}: {}", e.version, t.lines().last().unwrap_or("curl failed")));
+    }
+    std::fs::rename(&part, &file).map_err(|er| er.to_string())?;
+    let r = install_bundle(e, &file, dir, manifest::OTA_PUBLIC_KEY_HEX);
+    if r.is_err() {
+        let _ = std::fs::remove_file(&file);
+    }
+    r
+}
+
+/// The content type a served bundle file gets (the same list the embedded files use).
+pub fn content_type(rel: &str) -> &'static str {
+    if rel.ends_with(".html") { "text/html; charset=utf-8" } else if rel.ends_with(".css") { "text/css; charset=utf-8" } else if rel.ends_with(".js") { "application/javascript; charset=utf-8" } else if rel.ends_with(".svg") { "image/svg+xml" } else if rel.ends_with(".woff2") { "font/woff2" } else { "text/plain; charset=utf-8" }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ed25519_dalek::{Signer, SigningKey};
+
+    fn entry(version: &str, min_engine: &str) -> UiEntry {
+        UiEntry { version: version.into(), sha256: "ab".repeat(32), size: 1, url: "https://dl.igneum.network/dl/x/ui/igneum-ui-1.0.1.tar.gz".into(), min_engine: min_engine.into(), signature: "cd".repeat(64) }
+    }
+
+    #[test]
+    fn the_decision_covers_every_reason_to_skip() {
+        let e = entry("1.0.1", "0.3.19");
+        assert_eq!(decide(&e, "0.3.19", "1.0.0", Some("embedded"), &[], false), Decision::Apply);
+        assert_eq!(decide(&e, "0.3.20", "1.0.0", Some("1.0.0"), &[], false), Decision::Apply);
+        assert!(matches!(decide(&e, "0.3.18", "1.0.0", Some("embedded"), &[], false), Decision::Skip(w) if w.contains("needs engine 0.3.19")), "a too-new min_engine is ignored");
+        assert!(matches!(decide(&e, "0.3.19", "1.0.0", Some("1.0.1"), &[], false), Decision::Skip(w) if w.contains("is active")));
+        assert!(matches!(decide(&e, "0.3.19", "1.0.1", Some("embedded"), &[], false), Decision::Skip(w) if w.contains("built-in one")));
+        assert!(matches!(decide(&e, "0.3.19", "1.0.0", Some("embedded"), &["1.0.1".to_string()], false), Decision::Skip(w) if w.contains("failed here before")));
+        assert!(matches!(decide(&e, "0.3.19", "1.0.0", Some("embedded"), &[], true), Decision::Skip(w) if w.contains("chosen in Settings")));
+    }
+
+    /// A bundle folder, packed with the system tar, hashed and signed with a throwaway key.
+    fn make_bundle(root: &Path, version: &str, with_index: bool, sk: &SigningKey) -> (UiEntry, PathBuf) {
+        let src = root.join("src");
+        let _ = std::fs::remove_dir_all(&src);
+        std::fs::create_dir_all(src.join("fonts")).unwrap();
+        if with_index {
+            std::fs::write(src.join("index.html"), "<!doctype html><title>x</title>").unwrap();
+        }
+        std::fs::write(src.join("app.js"), "var x = 1;").unwrap();
+        std::fs::write(src.join("app.css"), "body{}").unwrap();
+        std::fs::write(src.join("VERSION"), format!("{version}\n")).unwrap();
+        std::fs::write(src.join("fonts/IBMPlexMono-400.woff2"), b"wOF2").unwrap();
+        let tar = root.join(format!("igneum-ui-{version}.tar.gz"));
+        let mut c = std::process::Command::new("tar");
+        c.args(["-czf", &tar.display().to_string(), "-C", &src.display().to_string(), "."]);
+        let ok = crate::platform::quiet(&mut c).status().unwrap().success();
+        assert!(ok, "tar packs the fixture");
+        let sha = manifest::sha256_file(&tar).unwrap();
+        let size = std::fs::metadata(&tar).unwrap().len();
+        let sig = manifest::hex_encode(&sk.sign(&manifest::ui_sign_bytes(version, &sha, "0.3.19")).to_bytes());
+        (UiEntry { version: version.into(), sha256: sha, size, url: "https://dl.igneum.network/dl/x/ui/x.tar.gz".into(), min_engine: "0.3.19".into(), signature: sig }, tar)
+    }
+
+    fn tmp(name: &str) -> PathBuf {
+        let d = std::env::temp_dir().join(format!("igneum-uiota-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&d);
+        std::fs::create_dir_all(&d).unwrap();
+        d
+    }
+
+    #[test]
+    fn a_good_bundle_installs_and_the_pointer_swaps_atomically() {
+        let root = tmp("good");
+        let sk = SigningKey::from_bytes(&[7u8; 32]);
+        let pk = manifest::hex_encode(sk.verifying_key().as_bytes());
+        let (e, tar) = make_bundle(&root, "1.0.1", true, &sk);
+        let dir = root.join("ui");
+        let dest = install_bundle(&e, &tar, &dir, &pk).expect("installs");
+        assert_eq!(dest, dir.join("1.0.1"));
+        assert!(bundle_dir(&dir, "1.0.1").is_some());
+        assert!(!dir.join("1.0.1.new").exists(), "the staging folder is gone");
+        write_current(&dir, &Current { version: "1.0.1".into(), installed_at: 5, confirmed: false }).unwrap();
+        assert_eq!(read_current(&dir).version, "1.0.1");
+        assert!(!dir.join("current.json.tmp").exists());
+        assert_eq!(content_type("app.js"), "application/javascript; charset=utf-8");
+        assert_eq!(bundle_dir(&dir, "embedded"), None);
+    }
+
+    #[test]
+    fn a_bad_signature_is_refused_before_anything_is_unpacked() {
+        let root = tmp("badsig");
+        let sk = SigningKey::from_bytes(&[7u8; 32]);
+        let other = manifest::hex_encode(SigningKey::from_bytes(&[8u8; 32]).verifying_key().as_bytes());
+        let (e, tar) = make_bundle(&root, "1.0.2", true, &sk);
+        let dir = root.join("ui");
+        let err = install_bundle(&e, &tar, &dir, &other).unwrap_err();
+        assert!(err.contains("signature does not verify"), "{err}");
+        assert!(!dir.join("1.0.2").exists());
+        // a tampered hash is caught first
+        let mut t = e.clone();
+        t.sha256 = "00".repeat(32);
+        let err = install_bundle(&t, &tar, &dir, &manifest::hex_encode(sk.verifying_key().as_bytes())).unwrap_err();
+        assert!(err.contains("sha256 mismatch"), "{err}");
+        // a wrong size too
+        let mut t = e.clone();
+        t.size += 1;
+        assert!(install_bundle(&t, &tar, &dir, &manifest::hex_encode(sk.verifying_key().as_bytes())).unwrap_err().contains("bytes"));
+    }
+
+    #[test]
+    fn a_broken_bundle_without_index_html_is_refused_and_leaves_nothing_behind() {
+        let root = tmp("broken");
+        let sk = SigningKey::from_bytes(&[7u8; 32]);
+        let pk = manifest::hex_encode(sk.verifying_key().as_bytes());
+        let (e, tar) = make_bundle(&root, "1.0.3", false, &sk);
+        let dir = root.join("ui");
+        let err = install_bundle(&e, &tar, &dir, &pk).unwrap_err();
+        assert!(err.contains("no index.html"), "{err}");
+        assert!(!dir.join("1.0.3").exists() && !dir.join("1.0.3.new").exists());
+    }
+
+    #[test]
+    fn a_renamed_bundle_is_refused_by_its_version_file() {
+        let root = tmp("renamed");
+        let sk = SigningKey::from_bytes(&[7u8; 32]);
+        let pk = manifest::hex_encode(sk.verifying_key().as_bytes());
+        let (mut e, tar) = make_bundle(&root, "1.0.4", true, &sk);
+        e.version = "1.0.5".into();
+        e.signature = manifest::hex_encode(&sk.sign(&manifest::ui_sign_bytes("1.0.5", &e.sha256, "0.3.19")).to_bytes());
+        let err = install_bundle(&e, &tar, &root.join("ui"), &pk).unwrap_err();
+        assert!(err.contains("VERSION file says '1.0.4'"), "{err}");
+    }
+
+    #[test]
+    fn the_health_wait_rolls_back_to_the_embedded_interface_and_marks_the_version_bad() {
+        // the state machine without threads: a UiOta over a temp dir, driven by hand
+        let root = tmp("health");
+        let dir = root.join("ui");
+        std::fs::create_dir_all(dir.join("1.0.6")).unwrap();
+        for f in REQUIRED {
+            std::fs::write(dir.join("1.0.6").join(f), "x").unwrap();
+        }
+        write_current(&dir, &Current { version: "1.0.6".into(), installed_at: 1, confirmed: false }).unwrap();
+        let mut u = UiOta { dir: dir.clone(), current: read_current(&dir), bad: vec![], builtin: false, busy: false, entry: None, waiting: None, error: String::new(), last_skip: String::new(), health_wait: Duration::from_secs(10) };
+        let t0 = Instant::now();
+        u.page_loaded("1.0.6", t0);
+        assert!(u.waiting.is_some());
+        // a ping in time confirms
+        let shared = crate::engine::Shared::for_tests(root.join("data"));
+        u.health(&shared, None);
+        assert!(u.current.confirmed && u.waiting.is_none());
+        assert_eq!(read_current(&dir).confirmed, true);
+        // a second bundle that never answers
+        std::fs::create_dir_all(dir.join("1.0.7")).unwrap();
+        for f in REQUIRED {
+            std::fs::write(dir.join("1.0.7").join(f), "x").unwrap();
+        }
+        u.set_current(&shared, Current { version: "1.0.7".into(), installed_at: 2, confirmed: false });
+        u.page_loaded("1.0.7", t0);
+        u.tick(&shared, t0 + Duration::from_secs(9));
+        assert_eq!(u.current.version, "1.0.7", "still waiting inside the window");
+        u.tick(&shared, t0 + Duration::from_secs(10));
+        assert_eq!(u.current.version, "embedded", "rolled back");
+        assert_eq!(read_current(&dir).version, "embedded");
+        assert_eq!(read_bad(&dir), vec!["1.0.7".to_string()]);
+        assert!(shared.ui_dir().is_none(), "the server serves the embedded files again");
+        // a script error on first paint rolls back the same way
+        std::fs::create_dir_all(dir.join("1.0.8")).unwrap();
+        for f in REQUIRED {
+            std::fs::write(dir.join("1.0.8").join(f), "x").unwrap();
+        }
+        u.set_current(&shared, Current { version: "1.0.8".into(), installed_at: 3, confirmed: false });
+        u.page_loaded("1.0.8", t0);
+        u.health(&shared, Some("TypeError: x is not a function"));
+        assert_eq!(u.current.version, "embedded");
+        assert!(u.bad.contains(&"1.0.8".to_string()));
+        // and the decision never applies it again
+        let e = entry("1.0.8", "0.3.19");
+        assert!(matches!(decide(&e, "0.3.19", "1.0.0", Some("embedded"), &u.bad, false), Decision::Skip(_)));
+    }
+}

app/igneum-app/src/watchdog.rs

@@ -17,6 +17,11 @@
 
 /// No status line from a running miner for this long: restart it.
 pub const NO_STATUS_S: f64 = 90.0;
+/// A worker that gives no status within this many seconds of its start, with the node synced, is one restart then
+/// faulted (PC 1, 7 October 2026 04:51Z: the row asks for a fault line at 60 s).
+pub const START_S: f64 = 60.0;
+/// The start of a fault reason the node's readiness, not the card, explains: released when the node syncs.
+const NODE_FAULTS: [&str; 2] = ["no status line from the miner", "the worker gave no status within"];
 /// Hash rate 0 while the node is synced and the worker is ready for this long: restart the miner.
 pub const ZERO_RATE_S: f64 = 60.0;
 /// The miner is restarting its own worker: the app waits this long for `ready` before it steps in.
@@ -86,6 +91,14 @@ pub enum Event<'a> {
     Stopped,
     /// The user changed the card's settings: a faulted card may try again.
     Reset,
+    /// The node became synced: a card faulted for silence while the node was not ready tries again (PC 1, 7 October
+    /// 2026 04:51Z: every card faulted "no status line" during the post-relaunch sync and never came back).
+    NodeSynced,
+    /// The miner printed "template fetch timed out": it is alive and the node is not answering templates (PC 1,
+    /// 7 October 2026 04:51Z: the node reported synced from the first second while its finality replay blocked the
+    /// template RPC for three minutes; with no template the miner prints no status line). Silence is not the card's
+    /// fault while this goes on; the miner is judged again once templates flow.
+    TemplateTimeout,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -109,6 +122,15 @@ pub struct CardWatch {
     restarts: u32,
     faulted: Option<String>,
     last_fault: String,
+    /// the miner's last line was a template timeout (the node not answering), cleared by the next status line
+    templates_blocked: bool,
+}
+
+impl CardWatch {
+    /// True while the miner's last word was a template timeout: the node, not the card, holds the hashing.
+    pub fn templates_blocked(&self) -> bool {
+        self.templates_blocked
+    }
 }
 
 impl CardWatch {
@@ -162,6 +184,7 @@ impl CardWatch {
                 Action::None
             }
             Event::Status(s) => {
+                self.templates_blocked = false;
                 self.last_status_s = Some(now_s);
                 if s.hash_now > 0.0 {
                     self.zero_since = None;
@@ -207,9 +230,30 @@ impl CardWatch {
                 *self = Self::default();
                 Action::None
             }
+            Event::TemplateTimeout => {
+                // the miner's own heartbeat: every silence clock starts over from this line
+                self.started_s = Some(now_s);
+                if self.last_status_s.is_some() {
+                    self.last_status_s = Some(now_s);
+                }
+                self.zero_since = None;
+                self.templates_blocked = true;
+                Action::None
+            }
+            Event::NodeSynced => {
+                if self.faulted.as_deref().map(|f| NODE_FAULTS.iter().any(|p| f.starts_with(p))).unwrap_or(false) {
+                    *self = Self::default();
+                }
+                Action::None
+            }
         }
     }
 
+    /// True when the card is faulted for a reason the node's readiness explains (released by Event::NodeSynced).
+    pub fn faulted_by_node(&self) -> bool {
+        self.faulted.as_deref().map(|f| NODE_FAULTS.iter().any(|p| f.starts_with(p))).unwrap_or(false)
+    }
+
     /// Called every engine tick while the miner process is alive.
     pub fn tick(&mut self, now_s: f64, node_synced: bool) -> Action {
         if self.faulted.is_some() {
@@ -223,14 +267,23 @@ impl CardWatch {
             }
             return Action::None;
         }
+        if !node_synced {
+            // a miner is judged only while the node is synced: with no template it cannot print status, so the silence
+            // clocks (start, no status, zero rate) hold at now until the node is back (PC 1, 7 October 2026)
+            self.started_s = Some(now_s);
+            if self.last_status_s.is_some() {
+                self.last_status_s = Some(now_s);
+            }
+            self.zero_since = None;
+            return Action::None;
+        }
+        if !self.ready && self.last_status_s.is_none() && now_s - started > START_S {
+            return self.escalate(format!("the worker gave no status within {} s of starting", START_S as u64));
+        }
         let last = self.last_status_s.unwrap_or(started);
         if now_s - last > NO_STATUS_S {
             return self.escalate(format!("no status line from the miner for {} s", NO_STATUS_S as u64));
         }
-        if !node_synced {
-            // a zero rate while the node syncs is expected; the timer starts again once it is synced
-            self.zero_since = None;
-        }
         if node_synced && self.ready {
             if let Some(z) = self.zero_since {
                 if now_s - z >= ZERO_RATE_S {
@@ -488,6 +541,70 @@ mod tests {
         assert!(matches!(w.tick(240.0, true), Action::Restart(_)));
     }
 
+    /// PC 1, 7 October 2026 04:51:43Z (docs/plans/release-0.3.17.md, the PC 1 row): the app relaunched after the OTA
+    /// apply, started its workers while the node was still syncing, and every card ended "faulted: no status line from
+    /// the miner for 90 s (restarted once already)", pid 0, 0.0 MH/s from then on. Today's watchdog clocks the silence
+    /// while the node is not synced and never releases the fault.
+    #[test]
+    fn a_worker_started_while_the_node_syncs_is_not_faulted_and_a_faulted_one_returns_at_sync() {
+        // the recorded sequence (relaunch-engine-and-workers.txt): node synced=true from the first second, the miner
+        // started at +14 s, subscribed, then every template fetch timed out at 5 s for 180 s; no status line was printed
+        let mut r = CardWatch::new();
+        r.event(14.0, Event::Started);
+        let mut t = 19.0;
+        while t <= 200.0 {
+            r.event(t, Event::TemplateTimeout);
+            assert_eq!(r.tick(t + 1.0, true), Action::None, "at {t}: a miner whose template fetches time out is not faulted on silence");
+            assert!(r.templates_blocked());
+            t += 5.0;
+        }
+        // the node answers templates again: the miner prints status and is healthy
+        healthy(&mut r, 210.0, 400.0);
+        assert!(!r.templates_blocked());
+        assert_eq!(r.faulted(), None);
+        // a miner that stops printing even timeouts is judged again from its last line
+        let mut q = CardWatch::new();
+        q.event(0.0, Event::Started);
+        q.event(50.0, Event::TemplateTimeout);
+        assert_eq!(q.tick(109.0, true), Action::None);
+        assert!(matches!(q.tick(111.0, true), Action::Restart(_)), "60 s of nothing at all after the last timeout line");
+
+        let mut w = CardWatch::new();
+        w.event(0.0, Event::Started);
+        // the node reads unsynced for 200 s (the relaunch's sync): no verdict at all
+        let mut t = 5.0;
+        while t <= 200.0 {
+            assert_eq!(w.tick(t, false), Action::None, "at {t}: a miner is judged only while the node is synced");
+            t += 10.0;
+        }
+        // the node syncs; the worker answers inside 60 s and is healthy
+        assert_eq!(w.tick(210.0, true), Action::None);
+        w.event(230.0, Event::Ready);
+        healthy(&mut w, 240.0, 400.0);
+        assert_eq!(w.faulted(), None);
+        // the recorded state: a card faulted for silence while the node was not ready
+        let mut f = CardWatch::new();
+        f.event(0.0, Event::Started);
+        assert!(matches!(f.tick(100.0, true), Action::Restart(_)));
+        f.event(101.0, Event::Started);
+        let a = f.tick(200.0, true);
+        assert!(matches!(a, Action::Fault(ref r) if (r.starts_with("no status line from the miner") || r.starts_with("the worker gave no status within")) && r.contains("restarted once already")), "{a:?}");
+        assert!(f.faulted_by_node());
+        f.event(300.0, Event::NodeSynced);
+        assert_eq!(f.faulted(), None, "the node syncing releases a silence fault");
+        assert_eq!(f.watchdog_restarts(), 0);
+        // a fault the card owns (zero rate while synced) stays through NodeSynced
+        let mut z = CardWatch::new();
+        z.event(0.0, Event::Started);
+        z.event(1.0, Event::Ready);
+        let zero = parse_status(STATUS_OK.replace("now=124.10 MH/s", "now=0.00 MH/s").as_str()).unwrap();
+        for t in [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0] { z.event(t, Event::Status(&zero)); z.tick(t, true); }
+        assert!(z.faulted().is_none() || !z.faulted_by_node());
+        let before = z.faulted().map(|s| s.to_string());
+        z.event(500.0, Event::NodeSynced);
+        assert_eq!(z.faulted().map(|s| s.to_string()), before);
+    }
+
     #[test]
     fn no_status_for_90s_restarts() {
         let mut w = CardWatch::new();
@@ -502,10 +619,11 @@ mod tests {
 
     #[test]
     fn no_status_from_the_start() {
+        // a worker silent from its start, with the node synced, is judged at START_S (60 s), not NO_STATUS_S
         let mut w = CardWatch::new();
         w.event(0.0, Event::Started);
-        assert_eq!(w.tick(89.0, true), Action::None);
-        assert!(matches!(w.tick(91.0, true), Action::Restart(_)));
+        assert_eq!(w.tick(59.0, true), Action::None);
+        assert!(matches!(w.tick(61.0, true), Action::Restart(ref r) if r.contains("gave no status within 60 s")));
     }
 
     #[test]

app/igneum-app/ui/VERSION

@@ -0,0 +1 @@
+1.0.0

app/igneum-app/ui/app.css

@@ -24,13 +24,15 @@
   --s-1:4px;--s-2:8px;--s-3:12px;--s-4:16px;--s-5:24px;--s-6:32px;
   --gutter:var(--s-6);--card-pad:var(--s-5);--card-r:16px;--row-r:12px;--gap:var(--s-4);
   --sans:'IBM Plex Sans',system-ui,-apple-system,sans-serif;--mono:'IBM Plex Mono',ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;--head:'Unbounded',sans-serif;
-  --top:60px;--bottom:0px;--drawer-h:260px;--rail:196px}
+  --top:60px;--bottom:0px;--drawer-h:260px;--rail:196px;
+  /* the chain scene's inclusion colours (EMBER 02 live-dag.js reads them from :root) */
+  --included:#3B7DD8;--excluded:#B0362B}
 @media (prefers-color-scheme:light){:root:not([data-theme="dark"]){
   --obsidian:#F4F1EC;--graphite:#FFFFFF;--row:#FAF8F5;--line:#E2DED8;--line-2:#CFCAC2;--ember:#E04A14;--ember-hi:#F2541B;--molten:#B8731F;--bone:#16161A;--ash:#6B6B70;--ink-2:#3C3C42;--ember-ink:#FFFFFF;
-  --ember-12:rgba(224,74,20,.1);--ember-40:rgba(224,74,20,.4);--molten-10:rgba(184,115,31,.1);--molten-40:rgba(184,115,31,.4);--nvidia:#3C9B2C;--rail-bg:#EFEBE4;--hover:rgba(0,0,0,.04);--top-bg:rgba(244,241,236,.88);--shadow:rgba(0,0,0,.18);--scrim:rgba(244,241,236,.72);--ok:#B8731F}}
+  --ember-12:rgba(224,74,20,.1);--ember-40:rgba(224,74,20,.4);--molten-10:rgba(184,115,31,.1);--molten-40:rgba(184,115,31,.4);--nvidia:#3C9B2C;--rail-bg:#EFEBE4;--hover:rgba(0,0,0,.04);--top-bg:rgba(244,241,236,.88);--shadow:rgba(0,0,0,.18);--scrim:rgba(244,241,236,.72);--ok:#B8731F;--included:#2A62B8;--excluded:#B0362B}}
 :root[data-theme="light"]{
   --obsidian:#F4F1EC;--graphite:#FFFFFF;--row:#FAF8F5;--line:#E2DED8;--line-2:#CFCAC2;--ember:#E04A14;--ember-hi:#F2541B;--molten:#B8731F;--bone:#16161A;--ash:#6B6B70;--ink-2:#3C3C42;--ember-ink:#FFFFFF;
-  --ember-12:rgba(224,74,20,.1);--ember-40:rgba(224,74,20,.4);--molten-10:rgba(184,115,31,.1);--molten-40:rgba(184,115,31,.4);--nvidia:#3C9B2C;--rail-bg:#EFEBE4;--hover:rgba(0,0,0,.04);--top-bg:rgba(244,241,236,.88);--shadow:rgba(0,0,0,.18);--scrim:rgba(244,241,236,.72);--ok:#B8731F}
+  --ember-12:rgba(224,74,20,.1);--ember-40:rgba(224,74,20,.4);--molten-10:rgba(184,115,31,.1);--molten-40:rgba(184,115,31,.4);--nvidia:#3C9B2C;--rail-bg:#EFEBE4;--hover:rgba(0,0,0,.04);--top-bg:rgba(244,241,236,.88);--shadow:rgba(0,0,0,.18);--scrim:rgba(244,241,236,.72);--ok:#B8731F;--included:#2A62B8;--excluded:#B0362B}
 *{box-sizing:border-box}
 html,body{height:100%}
 body{margin:0;background:var(--obsidian);color:var(--bone);font-family:var(--sans);font-size:var(--t-md);line-height:1.5;-webkit-font-smoothing:antialiased;overflow:hidden;user-select:none;-webkit-user-select:none;font-variant-numeric:tabular-nums}
@@ -61,7 +63,7 @@ input,textarea{font-variant-numeric:tabular-nums}
 .btn.tiny{min-height:26px;padding:2px 10px;font-size:var(--t-sm);border-radius:7px;font-family:var(--mono);font-weight:500}
 .btn.ghost{border-color:transparent;color:var(--ink-2)}
 .btn.ghost:hover{border-color:var(--line-2);color:var(--bone)}
-.btn.ghost.on{color:var(--molten);border-color:var(--molten-40);background:var(--molten-10)}
+.btn.ghost.on{color:var(--molten);border-color:var(--molten-40)}
 .btn.danger:hover{color:var(--ember);border-color:var(--ember)}
 :focus-visible{outline:2px solid var(--ember);outline-offset:3px;border-radius:6px}
 @media (prefers-reduced-motion:reduce){.btn{transition:none}}
@@ -77,7 +79,7 @@ body.mac .rail-brand{padding-top:30px}
 .nav svg{width:19px;height:19px;flex:0 0 19px;fill:none;stroke:currentColor;stroke-width:1.9;stroke-linecap:round;stroke-linejoin:round;color:var(--ash);transition:color .15s ease}
 .nav:hover{background:var(--hover);color:var(--bone)}
 .nav:hover svg{color:var(--ink-2)}
-.nav.on{background:var(--ember-12);border-color:var(--ember-40);color:var(--bone);font-weight:600}
+.nav.on{background:var(--hover);border-color:var(--line);color:var(--bone);font-weight:600}
 .nav.on svg{color:var(--ember)}
 .nav.on::before{content:"";position:absolute;left:-13px;top:10px;bottom:10px;width:3px;border-radius:0 3px 3px 0;background:var(--ember)}
 .nav.small{min-height:36px;font-size:var(--t-base);color:var(--ash)}
@@ -99,13 +101,15 @@ body.has-rail .top{left:var(--rail)}
 .brand{display:flex;align-items:center;gap:10px;min-width:0}
 .brand .word{font-family:var(--head);font-weight:900;font-size:20px;letter-spacing:.06em}
 .brand .miner{font-family:var(--mono);font-size:var(--t-xs);letter-spacing:.22em;color:var(--ash);margin-left:var(--s-1);padding-top:3px}
+body.has-rail .top{align-items:baseline;padding-top:19px}
 .page-title{display:flex;align-items:baseline;gap:12px;min-width:0}
 .page-title h1{font-size:19px;font-weight:700;letter-spacing:0;white-space:nowrap}
 .page-sub{font-size:var(--t-base);color:var(--ash);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;min-width:0}
 .top-right{display:flex;align-items:center;gap:var(--s-3);flex:0 0 auto;min-width:0}
-.pill{display:inline-flex;align-items:center;gap:var(--s-2);font-family:var(--mono);font-size:var(--t-sm);letter-spacing:.08em;text-transform:uppercase;color:var(--ash);border:1px solid var(--line);border-radius:999px;padding:6px 12px 6px 10px;background:var(--graphite);white-space:nowrap;font-variant-numeric:tabular-nums;min-width:112px;justify-content:center}
+.pill{display:inline-flex;align-items:baseline;gap:var(--s-2);font-family:var(--sans);font-size:var(--t-base);font-weight:600;color:var(--ash);border:1px solid var(--line);border-radius:999px;padding:5px 12px 5px 10px;background:var(--graphite);white-space:nowrap;font-variant-numeric:tabular-nums;justify-content:center;line-height:1.3}
+.pill .dot{position:relative;top:-1px}
 .pill.on{color:var(--molten);border-color:var(--molten-40)}
-.pill.warn{color:var(--ember)}
+.pill.warn{color:var(--ember);border-color:var(--ember-40)}
 .dot{width:8px;height:8px;border-radius:50%;background:var(--ash);display:inline-block;flex:0 0 8px}
 .on .dot,.dot.live{background:var(--molten);animation:pulse 2s ease-in-out infinite}
 .warn .dot,.dot.bad{background:var(--ember);animation:none}
@@ -116,26 +120,30 @@ body.has-rail .top{left:var(--rail)}
    top moves once per change with a 150 ms transition (layoutStrip), never per poll. */
 .notices{position:fixed;top:var(--top);left:0;right:0;z-index:19}
 body.has-rail .notices{left:var(--rail)}
-.notice{display:flex;flex-wrap:wrap;align-items:center;gap:var(--s-2) var(--s-4);padding:8px calc(var(--gutter) - 6px) 8px var(--gutter);background:var(--molten-10);border-bottom:1px solid var(--molten-40);font-size:var(--t-base);line-height:1.4;color:var(--bone)}
-.notice.bad{background:var(--ember-12);border-bottom-color:var(--ember-40)}
-.notice.warn{background:var(--molten-10);border-bottom-color:var(--molten-40)}
-.notice.update-urgent{background:rgba(242,84,27,.55);border-bottom-color:var(--ember);color:#fff;font-weight:600}
+.notice{display:flex;flex-wrap:wrap;align-items:center;gap:var(--s-2) var(--s-3);padding:9px calc(var(--gutter) - 6px) 9px var(--gutter);background:var(--row);border-bottom:1px solid var(--line);box-shadow:inset 0 1px 0 var(--ember);font-size:var(--t-base);line-height:1.4;color:var(--ash)}
+.notice-dot{width:7px;height:7px;border-radius:50%;background:var(--ember);flex:0 0 7px;display:inline-block}
+.notice.bad .notice-text,.notice.update-urgent .notice-text{color:var(--bone)}
+.notice.update-urgent .notice-text{font-weight:600}
+.notice .notice-text b{color:var(--bone);font-weight:600}
 .notice-text{flex:1 1 320px;min-width:0}
 .notice-actions{display:flex;align-items:center;gap:var(--s-2);flex:0 0 auto}
 .notice-actions:empty{display:none}
 .notice-close{flex:0 0 auto;width:30px;height:30px;border-radius:8px;border:1px solid transparent;background:transparent;color:var(--ash);font-size:20px;line-height:1;cursor:pointer;display:inline-flex;align-items:center;justify-content:center;padding:0}
 .notice-close:hover{color:var(--bone);border-color:var(--line-2)}
-.notice.update-urgent .notice-close{color:#fff}
-.notice-detail{flex-basis:100%;font-size:var(--t-sm);color:var(--ink-2);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;margin-top:-3px}
-.notice .prog{flex-basis:100%;height:3px;background:rgba(127,127,127,.2);border-radius:2px;overflow:hidden;margin-top:-3px}
+.notice-more{flex:0 0 auto;width:30px;height:30px;border-radius:8px;border:1px solid transparent;background:transparent;color:var(--ash);cursor:pointer;display:inline-flex;align-items:center;justify-content:center;padding:0}
+.notice-more:hover{color:var(--bone);border-color:var(--line-2)}
+.notice-more .chev{width:8px;height:8px;transform:rotate(45deg) translateY(-2px)}
+.notice-more.open .chev{transform:rotate(225deg) translateY(-2px)}
+.notice-detail{flex-basis:100%;font-family:var(--mono);font-size:var(--t-sm);color:var(--ink-2);white-space:normal;word-break:break-word;margin-top:-2px;user-select:text;-webkit-user-select:text}
+.notice .prog{flex-basis:100%;height:2px;background:var(--line);border-radius:2px;overflow:hidden;margin-top:-3px}
 .notice .prog i{display:block;height:100%;width:0;background:var(--ember);transition:width .5s linear}
 
 /* a question in place of a dialog: the quit strip over the page, the inline asks inside a card */
 .ask-wrap{position:fixed;left:0;right:0;bottom:0;z-index:36;display:flex;justify-content:center;padding:0 var(--s-4) var(--s-4);pointer-events:none}
 body.has-rail .ask-wrap{left:var(--rail)}
-.ask{display:flex;align-items:center;gap:var(--s-3);flex-wrap:wrap;background:var(--graphite);border:1px solid var(--ember-40);border-radius:14px;padding:12px 16px;box-shadow:0 14px 40px var(--shadow);pointer-events:auto;max-width:720px;animation:rise .2s ease}
+.ask{display:flex;align-items:center;gap:var(--s-3);flex-wrap:wrap;background:var(--row);border:1px solid var(--line);border-radius:14px;padding:12px 16px;box-shadow:inset 0 1px 0 var(--ember),0 14px 40px var(--shadow);pointer-events:auto;max-width:720px;animation:rise .2s ease}
 .ask-text{flex:1 1 260px;font-size:var(--t-md);min-width:0}
-.ask.inline{box-shadow:none;background:var(--ember-12);margin-top:var(--s-3);animation:none}
+.ask.inline{box-shadow:inset 0 1px 0 var(--ember);background:var(--row);margin-top:var(--s-3);animation:none}
 
 /* screens and pages */
 main{position:absolute;top:var(--top);bottom:var(--bottom);left:0;right:0;overflow:auto;padding:0 var(--gutter);overscroll-behavior:contain;transition:top .15s ease}
@@ -214,7 +222,7 @@ body[data-phase="welcome"] #screen-welcome,body[data-phase="cards"] #screen-card
 .toggle-big .ts{font-family:var(--mono);font-size:var(--t-xs);letter-spacing:.06em;opacity:.8;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%}
 .toggle-big.stop{background:var(--graphite);border-color:var(--line-2);color:var(--bone)}
 .toggle-big.stop:hover{border-color:var(--ash);background:var(--row)}
-.toggle-big.stop .ring{background:var(--ember-12);color:var(--ember)}
+.toggle-big.stop .ring{background:var(--obsidian);border:1px solid var(--line-2);color:var(--ember)}
 .toggle-big.stop .ts{color:var(--molten);opacity:1}
 .totals{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:var(--s-3);background:var(--graphite);border:1px solid var(--line);border-radius:14px;padding:18px 20px;min-width:0}
 .tot{display:flex;flex-direction:column;min-width:0;padding-left:var(--s-4);border-left:1px solid var(--line)}
@@ -246,9 +254,10 @@ body[data-phase="welcome"] #screen-welcome,body[data-phase="cards"] #screen-card
 .feed>div:last-child{border-bottom:0}
 .feed>div>span:first-child{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .feed .t{color:var(--ash);flex:0 0 auto;font-size:var(--t-xs)}
-.feed .k{color:var(--molten);margin-right:6px}
-.feed .k.error,.feed .k.warn,.feed .k.block{color:var(--ember)}
-.feed .k.build,.feed .k.info{color:var(--ash)}
+.feed .k{display:inline-block;width:7px;height:7px;border-radius:50%;background:var(--molten);margin-right:10px;position:relative;top:-1px}
+.feed .k.error,.feed .k.warn,.feed .k.block{background:var(--ember)}
+.feed .k.build,.feed .k.info{background:var(--line-2)}
+.feed .k.proving{background:var(--nvidia)}
 
 /* the card rows on Mine (the hero object): badge, name and state, the numbers, Tune, the switch, the chevron;
    the tune line under; the details under that */
@@ -349,8 +358,8 @@ table{border-collapse:collapse;width:100%;font-size:var(--t-base)}
 #s-jobs-history td{padding:6px 6px 6px 0;border-top:1px solid var(--line);vertical-align:top}
 #s-jobs-history tr.failed td,#s-jobs-history tr.timeout td,#s-jobs-history tr.aborted td{color:var(--ember)}
 #s-jobs-history tr.running td{color:var(--molten)}
-.clock-card{border:1px solid var(--ember-40);background:var(--ember-12);border-radius:12px;padding:12px 14px;display:flex;flex-direction:column;gap:var(--s-2)}
-.clock-card.warn{border-color:var(--molten-40);background:var(--molten-10)}
+.clock-card{border:1px solid var(--line);background:var(--row);box-shadow:inset 0 1px 0 var(--ember);border-radius:12px;padding:12px 14px;display:flex;flex-direction:column;gap:var(--s-2)}
+.clock-card.warn{box-shadow:inset 0 1px 0 var(--molten)}
 .clock-msg{font-size:var(--t-md);color:var(--bone);line-height:1.45}
 .clock-card .note{margin-top:0}
 
@@ -360,6 +369,8 @@ table{border-collapse:collapse;width:100%;font-size:var(--t-base)}
 .money-row:last-child{border-bottom:0}
 .money-row .v{font-family:var(--head);font-weight:700;font-size:var(--t-hero);line-height:1.1;white-space:nowrap;letter-spacing:-.01em;min-width:200px}
 .money-row .v.small{font-size:var(--t-num)}
+.money-row .v.tiny{font-family:var(--sans);font-size:var(--t-lg);font-weight:600;white-space:normal;min-width:0;line-height:1.35}
+@media (max-width:720px){.money-row .v{white-space:normal;min-width:0;font-size:var(--t-h2)}.money-row .v.small{font-size:var(--t-xl)}}
 .money-row .s{font-size:var(--t-base);color:var(--ash);min-width:0}
 
 /* prove */
@@ -372,7 +383,7 @@ table{border-collapse:collapse;width:100%;font-size:var(--t-base)}
 .options{display:flex;flex-direction:column;gap:var(--s-3);margin-top:6px}
 .option{display:flex;gap:var(--s-4);align-items:flex-start;background:var(--graphite);border:1px solid var(--line);border-radius:var(--card-r);padding:20px 22px;cursor:pointer;transition:border-color .15s ease,background .15s ease}
 .option:hover{border-color:var(--line-2)}
-.option.on{border-color:var(--ember);background:var(--ember-12)}
+.option.on{border-color:var(--ember);background:var(--row)}
 .option input[type=radio]{position:absolute;opacity:0;width:0;height:0}
 .option .radio{width:20px;height:20px;border-radius:50%;border:2px solid var(--line-2);flex:0 0 20px;margin-top:2px;position:relative}
 .option.on .radio{border-color:var(--ember)}
@@ -506,8 +517,8 @@ body.drawer-drag main{pointer-events:none}
 .log .src.app{color:var(--ember)}
 .log .src.watch{color:var(--ash)}
 .log .e,.log .e .src{color:var(--ember)}
-.log .ln.hit{background:rgba(255,179,92,.18);box-shadow:inset 3px 0 0 var(--molten);margin:0 calc(-1 * var(--gutter));padding:0 var(--gutter)}
-.log mark{background:rgba(255,179,92,.3);color:var(--bone);border-radius:2px;padding:0 1px}
+.log .ln.hit{background:var(--hover);box-shadow:inset 3px 0 0 var(--molten);margin:0 calc(-1 * var(--gutter));padding:0 var(--gutter)}
+.log mark{background:transparent;color:var(--bone);text-decoration:underline;text-decoration-color:var(--ember);text-underline-offset:2px}
 .log-empty{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;color:var(--ash);font-size:var(--t-sm);padding:0 var(--gutter);text-align:center}
 .log-jump{position:absolute;right:calc(var(--gutter) + 14px);bottom:14px;background:var(--graphite);border-color:var(--molten-40);color:var(--molten);box-shadow:0 8px 24px var(--shadow);z-index:2;gap:6px;padding:6px 12px}
 .log-jump:hover{border-color:var(--molten)}
@@ -590,6 +601,8 @@ body.drawer-open .toast{bottom:calc(var(--drawer-h) + 16px)}
   .step{padding:32px 0}
   .money-row .v{font-size:var(--t-num)}
   .drawer-head{padding-left:var(--s-4);padding-right:var(--s-4)}
+  .notice{padding-left:var(--s-4);padding-right:var(--s-2);gap:var(--s-2)}
+  .notice-text{flex-basis:160px}
   .log,.log-ruler .t0,.log-ruler .t1{padding-left:var(--s-4);padding-right:var(--s-4)}
 }
 /* short windows (the 600 px floor): tighter paddings, a smaller canvas, so the drawer always has room */
@@ -605,3 +618,175 @@ body.drawer-open .toast{bottom:calc(var(--drawer-h) + 16px)}
   .drawer-head{padding-bottom:6px}
   .toggle-big{min-height:96px}
 }
+
+/* miner-ui-4 (6 October 2026): Overview and Cards. The Overview hero (the project lead's pick, C): the fleet rate at 84 px on a
+   graphite-to-obsidian fade with W, £ a day and blocks beside it, Start/Stop as the full-width bar under it. */
+.hero-row{grid-template-columns:1fr}
+.totals{order:1;grid-template-columns:2fr 1fr 1fr 1fr;align-items:end;padding:28px 28px 24px;border-color:transparent;background:linear-gradient(180deg,var(--graphite),var(--obsidian))}
+.tot{border-left:0;padding-left:0}
+.tot:first-child .v{font-size:84px;line-height:.95;letter-spacing:-.03em}
+.tot:first-child .k{font-size:var(--t-sm);margin-top:10px}
+.tot:first-child .s{font-size:var(--t-md)}
+.tot .v{font-size:30px}
+.tot .v.ask-price{font-size:var(--t-md);padding:9px 0 8px}
+.toggle-big{order:2;min-height:64px;flex-direction:row;align-items:center;gap:14px;padding:12px 20px}
+.toggle-big .ring{margin:0}
+.toggle-big .ts{margin-left:auto}
+/* the chain scene: the site's live-dag.js in a 220 px box, the legend words under it, the blocks strip as the fallback */
+.dag-wrap{position:relative}
+#dag-live{display:block;width:100%;height:220px;border-radius:10px;background:var(--obsidian);border:1px solid var(--line)}
+#dag{height:120px;margin-bottom:0}
+.dag-tip{position:absolute;left:0;top:0;pointer-events:none;background:var(--graphite);border:1px solid var(--line-2);border-radius:8px;padding:8px 10px;font-size:var(--t-xs);color:var(--ink-2);display:flex;flex-direction:column;gap:2px;max-width:320px;box-shadow:0 8px 24px var(--shadow);z-index:3}
+.dag-tip b{color:var(--bone);font-weight:500;word-break:break-all}
+.dag-chip{position:absolute;right:10px;top:10px;font-size:var(--t-xs);color:var(--ash);background:var(--graphite);border:1px solid var(--line-2);border-radius:999px;padding:3px 10px;pointer-events:none;z-index:2}
+.legend{display:flex;flex-wrap:wrap;gap:8px 16px;margin-top:var(--s-3);font-size:var(--t-sm);color:var(--ash);align-items:center}
+.legend span{display:inline-flex;align-items:center;gap:7px}
+.lg{width:10px;height:10px;border-radius:3px;display:inline-block;border:1.5px solid var(--ash);background:var(--row)}
+.lg.you{border-color:var(--molten);box-shadow:0 0 0 2px var(--molten-40)}
+.lg.pending{border-color:var(--ash)}
+.lg.included{border-color:var(--ember)}
+.lg.excluded{border-color:var(--ash);opacity:.45}
+.lg.proven{background:var(--ember);border-color:var(--ember)}
+.lg.locked{border-color:var(--ember);border-radius:50%;box-shadow:0 0 0 2px var(--ember-40)}
+/* Cards: the Tuning strip above the list */
+.tune-strip{padding:var(--s-4) var(--card-pad)}
+.ts-row{display:flex;align-items:center;gap:var(--s-4);flex-wrap:wrap}
+.ts-row .goal-line{flex:0 1 auto}
+.ts-saving{font-size:var(--t-base);color:var(--molten);font-weight:500;margin-left:auto}
+.ts-saving:empty{display:none}
+.tune-strip .line-text{margin-top:var(--s-2);font-size:var(--t-base);color:var(--ash)}
+.tune-strip .switch{padding-bottom:0}
+/* the Ember layer on a row: the flame mark, the saving, the sparkline, the curve */
+.gl-tune{align-items:center}
+.flame{flex:0 0 16px;display:inline-block}
+.flame .fo{fill:none;stroke:var(--ash);stroke-width:7}
+.flame .ff{fill:var(--ember)}
+.flame.running .ff{fill:var(--molten)}
+.flame.measured .ff{fill:var(--ash)}
+.flame.idle .ff,.flame.paused .ff,.flame.stopped .ff{fill:none}
+.gl-tune.tuned .t{color:var(--ink-2)}
+.gl-tune .save,.gl-details .save{color:var(--molten);white-space:nowrap}
+.num .k.spark{display:inline-flex;align-items:center;gap:6px}
+.spark{display:inline-block;vertical-align:middle}
+.spark path{fill:none;stroke:var(--ash);stroke-width:1.2}
+.spark circle{fill:var(--ember)}
+.curve-wrap{display:flex;flex-direction:column;gap:6px;max-width:420px}
+.curve-svg{width:100%;height:auto;background:var(--obsidian);border:1px solid var(--line);border-radius:10px}
+.curve-svg .ln{fill:none;stroke:var(--ash);stroke-width:1.2}
+.curve-svg circle{fill:var(--ember)}
+.curve-svg circle.chosen{fill:none;stroke:var(--ember);stroke-width:2}
+.curve-svg circle.marked{fill:none;stroke:var(--ash);stroke-width:1.2}
+.curve-svg text{font-family:var(--mono);font-size:9px;fill:var(--ash)}
+.seg.small .seg-b{padding:4px 10px;font-size:var(--t-sm)}
+.gl-details .ctl .seg{justify-self:start}
+@media (max-width:1180px){
+  .totals{grid-template-columns:1fr 1fr 1fr 1fr}
+  .tot:first-child .v{font-size:64px}
+}
+@media (max-width:860px){
+  .totals{grid-template-columns:1fr 1fr;row-gap:var(--s-4)}
+  .tot:first-child{grid-column:1 / -1}
+  .tot:nth-child(3){padding-left:0}
+}
+@media (max-width:720px){
+  .tot:first-child .v{font-size:56px}
+  .toggle-big .ts{display:none}
+  #dag-live{height:170px}
+  .ts-saving{margin-left:0}
+  .legend{gap:6px 12px}
+  .rail-foot .nav.small{padding:6px 4px}
+}
+
+/* ---- miner-ui-5: the miner's first month: the count-up, the block card, the ladder strip, the rungs, the timeline ---- */
+.wait-card{background:var(--row);padding:16px 20px}
+.wait-row{display:flex;align-items:center;gap:var(--s-4)}
+.wait-ring{position:relative;width:52px;height:52px;flex:0 0 52px;display:inline-flex;align-items:center;justify-content:center}
+.wait-ring svg{position:absolute;inset:0;width:52px;height:52px;transform:rotate(-90deg)}
+.wait-ring .track{fill:none;stroke:var(--line);stroke-width:3}
+.wait-ring .arc{fill:none;stroke:var(--molten);stroke-width:3;stroke-linecap:round;stroke-dasharray:97.4;stroke-dashoffset:97.4;transition:stroke-dashoffset .6s ease}
+.wait-ring .pct{font-size:var(--t-xs);color:var(--molten)}
+.wait-text .t{font-size:var(--t-md);color:var(--bone)}
+.wait-text .s{font-size:var(--t-sm);color:var(--ash);margin-top:2px}
+.block-card{position:relative;background:linear-gradient(135deg,var(--graphite),var(--row));border-color:var(--line-2);box-shadow:inset 0 1px 0 var(--ember),0 18px 50px var(--shadow);user-select:text;-webkit-user-select:text}
+.bc-head{display:flex;align-items:center;gap:var(--s-3);margin-bottom:var(--s-2)}
+.bc-when{margin-left:auto;font-size:var(--t-xs);color:var(--ash)}
+.bc-close{position:static;margin-left:4px}
+.bc-title{font-size:var(--t-h1);letter-spacing:-.02em;margin-bottom:var(--s-2)}
+.bc-title.small{font-size:var(--t-h2)}
+.bc-line{font-size:var(--t-lg);color:var(--ink-2);margin:2px 0}
+.bc-line.dim{color:var(--ash);font-size:var(--t-md)}
+.bc-hash{font-size:var(--t-sm);color:var(--ash);margin:8px 0 12px;word-break:break-all}
+.shard-card{box-shadow:inset 0 1px 0 var(--nvidia)}
+.ladder-strip{padding:14px 20px}
+.ls-rungs{display:flex;gap:4px;flex-wrap:wrap;margin-bottom:10px}
+.ls-rung{display:inline-flex;align-items:center;gap:7px;font-family:var(--mono);font-size:var(--t-xs);letter-spacing:.04em;color:var(--ash);padding:4px 10px 4px 6px;border:1px solid var(--line);border-radius:999px;white-space:nowrap}
+.ls-rung i{width:8px;height:8px;border-radius:50%;background:var(--line-2);display:inline-block}
+.ls-rung.done{color:var(--molten);border-color:var(--molten-40)}
+.ls-rung.done i{background:var(--molten)}
+.ls-rung.now{color:var(--bone);border-color:var(--ember-40)}
+.ls-rung.now i{background:var(--ember);box-shadow:0 0 0 3px var(--ember-12)}
+.ls-rung.off{opacity:.55}
+.ls-line{display:flex;align-items:baseline;gap:var(--s-3);flex-wrap:wrap}
+.ls-line .t{font-size:var(--t-md);color:var(--bone);font-weight:500}
+.ls-line .s{font-size:var(--t-sm);min-width:0}
+.ls-line .btn{margin-left:auto}
+.rungs{list-style:none;margin:var(--s-3) 0 0;padding:0;display:flex;flex-direction:column}
+.rung{display:grid;grid-template-columns:22px 1fr;gap:var(--s-3);padding:10px 0;border-bottom:1px solid var(--line)}
+.rung:last-child{border-bottom:0}
+.rg-dot{width:12px;height:12px;border-radius:50%;background:var(--line-2);margin-top:5px;border:2px solid transparent;position:relative}
+.rung.done .rg-dot{background:var(--molten)}
+.rung.now .rg-dot{background:var(--ember);box-shadow:0 0 0 4px var(--ember-12)}
+.rung.off .rg-dot{background:transparent;border-color:var(--line-2)}
+.rg-body{display:flex;flex-direction:column;gap:2px;min-width:0}
+.rg-name{font-family:var(--mono);font-size:var(--t-xs);letter-spacing:.12em;text-transform:uppercase;color:var(--ash)}
+.rg-line{font-size:var(--t-lg);color:var(--bone)}
+.rung.done .rg-line{color:var(--molten)}
+.rung.next .rg-line,.rung.off .rg-line{color:var(--ash)}
+.rg-sub{font-size:var(--t-sm);color:var(--ash);line-height:1.45}
+.rung .bar{display:block;height:3px;border-radius:2px;background:var(--line);overflow:hidden;margin-top:6px;max-width:320px}
+.rung .bar b{display:block;height:100%;background:var(--ember)}
+.timeline{list-style:none;margin:0;padding:0;display:flex;flex-direction:column}
+.timeline li{display:grid;grid-template-columns:140px auto 1fr;gap:var(--s-3);align-items:baseline;padding:6px 0;border-bottom:1px solid var(--line);color:var(--ash);font-size:var(--t-md)}
+.timeline li:last-child{border-bottom:0}
+.timeline li.done{color:var(--bone)}
+.timeline .tl-at{font-size:var(--t-sm);color:var(--molten);white-space:nowrap}
+.timeline .tl-note{font-size:var(--t-sm);min-width:0}
+.money-row.price-row .row{gap:6px;align-items:center}
+.money-row .s+.s::before{content:"\00b7";margin-right:var(--s-2);color:var(--line-2)}
+.num.ign .v{color:var(--molten)}
+@media (max-width:720px){.bc-title{font-size:var(--t-h2)}.timeline li{grid-template-columns:110px auto 1fr}.ls-line .btn{margin-left:0}}
+
+/* ---- the full chain scene with the block inspector (EMBER 02; the words of the site's /live) ---- */
+.chain-full{margin-top:var(--s-3);border-top:1px solid var(--line);padding-top:var(--s-3)}
+.cf-bar{display:flex;justify-content:space-between;align-items:center;gap:var(--s-3);flex-wrap:wrap;margin-bottom:var(--s-3)}
+.cf-right{display:inline-flex;align-items:center;gap:var(--s-2)}
+.zoom{display:inline-flex;align-items:center;border:1px solid var(--line);border-radius:6px;overflow:hidden}
+.zoom button{background:transparent;border:0;color:var(--ink-2);font:400 13px/1 var(--mono);padding:7px 11px;cursor:pointer}
+.zoom button:hover{background:var(--hover)}
+.zoom span{font-size:var(--t-xs);color:var(--ash);padding:0 6px;min-width:44px;text-align:center}
+.cf-graph{display:grid;grid-template-columns:minmax(0,1fr) 250px;gap:var(--s-4)}
+.cf-scene{position:relative;min-width:0}
+.cf-scene canvas{display:block;width:100%;height:360px;border-radius:10px;background:var(--row);border:1px solid var(--line)}
+.cf-foot{margin-top:8px;font-size:var(--t-xs);color:var(--ash)}
+.inspector{min-width:0;font-size:var(--t-base);border-left:1px solid var(--line);padding-left:var(--s-4)}
+.inspector .ih{display:flex;justify-content:space-between;align-items:center;gap:8px;margin-bottom:10px}
+.chip{font-family:var(--mono);font-size:var(--t-xs);color:var(--ash);border:1px solid var(--line);border-radius:4px;padding:4px 8px;white-space:nowrap}
+.ititle{font-family:var(--sans);font-weight:500;font-size:20px;line-height:1.2;color:var(--bone);margin:6px 0 4px;letter-spacing:-.01em}
+.ihash{font-size:var(--t-xs);color:var(--ash);overflow-wrap:anywhere;margin-bottom:12px;user-select:text;-webkit-user-select:text}
+.proof-scene{height:180px;border:1px solid var(--line);border-radius:6px;background:var(--row);margin:10px 0;overflow:hidden}
+.proof-scene canvas{display:block;width:100%;height:100%}
+.proof-head{display:flex;justify-content:space-between;align-items:baseline;font-weight:500;color:var(--bone);margin-bottom:8px}
+.track{display:flex;gap:3px;height:3px;margin-bottom:10px}
+.track i{flex:1 1 0;background:var(--line);border-radius:2px}
+.track i.proving{background:var(--ember)}.track i.verified{background:var(--bone)}.track i.paid{background:var(--molten)}
+.shards{list-style:none;margin:0 0 12px;padding:0;font-size:var(--t-xs);line-height:1.7;max-height:120px;overflow:auto}
+.shards li{display:flex;justify-content:space-between;gap:8px;color:var(--ink-2)}
+.shards li::before{content:"\25CF";font-size:7px;margin-right:6px;color:var(--line-2)}
+.shards li.proving,.shards li.proving::before{color:var(--ember)}.shards li.verified,.shards li.verified::before{color:var(--bone)}.shards li.paid,.shards li.paid::before{color:var(--molten)}
+.shards li.muted{color:var(--ash)}
+.insp{display:grid;grid-template-columns:auto minmax(0,1fr);gap:0 10px;margin:0;border-top:1px solid var(--line);padding-top:6px;font-size:var(--t-xs)}
+.insp dt{color:var(--ash);padding:5px 0}
+.insp dd{margin:0;color:var(--bone);text-align:right;padding:5px 0;overflow-wrap:anywhere;min-width:0}
+.inspector .note{font-size:var(--t-sm);margin-top:12px;padding-top:10px;border-top:1px solid var(--line)}
+.inspector .top-gap{margin-top:8px}
+@media (max-width:900px){.cf-graph{grid-template-columns:1fr}.inspector{border-left:0;padding-left:0;border-top:1px solid var(--line);padding-top:var(--s-3)}}

app/igneum-app/ui/index.html

@@ -8,7 +8,7 @@
 <link rel="icon" href="mark.svg" type="image/svg+xml">
 <link rel="stylesheet" href="app.css">
 </head>
-<body class="phase-welcome" data-phase="welcome" data-page="mine">
+<body class="phase-welcome" data-phase="welcome" data-page="overview">
 
 <!-- the rail: four sections (miner-ui-3: Mine, Earnings, Prove, Settings), Logs and Quit in the foot. Under 720 px it
      is a bottom tab bar. The setup screens have no rail. -->
@@ -18,7 +18,8 @@
     <span class="word">IGNEUM</span>
   </div>
   <nav class="rail-nav" id="rail-nav" aria-label="Sections">
-    <button class="nav on" data-page="mine" aria-current="page"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M13 2 4 14h7l-1 8 9-12h-7l1-8z"/></svg><span>Mine</span></button>
+    <button class="nav on" data-page="overview" aria-current="page"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M13 2 4 14h7l-1 8 9-12h-7l1-8z"/></svg><span>Overview</span></button>
+    <button class="nav" data-page="cards"><svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="5" width="18" height="11" rx="2"/><path d="M7 20h10M9 16v4M15 16v4M7 10h3M14 10h3"/></svg><span>Cards</span></button>
     <button class="nav" data-page="earnings"><svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="6" width="18" height="13" rx="2"/><path d="M3 10h18M16 15h2"/></svg><span>Earnings</span></button>
     <button class="nav" data-page="prove"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M12 2 4 5v6c0 5 3.4 9.4 8 11 4.6-1.6 8-6 8-11V5l-8-3z"/><path d="m9 12 2 2 4-4"/></svg><span>Prove</span></button>
     <button class="nav" data-page="settings"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 7h10M18 7h2M4 17h4M12 17h8"/><circle cx="16" cy="7" r="2"/><circle cx="10" cy="17" r="2"/></svg><span>Settings</span><i class="nav-dot" id="nav-updates-dot" hidden></i></button>
@@ -37,7 +38,7 @@
     <span class="word">IGNEUM</span><span class="miner">MINER</span>
   </div>
   <div class="page-title" id="page-title" hidden>
-    <h1 id="page-title-text">Mine</h1>
+    <h1 id="page-title-text">Overview</h1>
     <span class="page-sub" id="page-sub"></span>
   </div>
   <div class="top-right">
@@ -48,8 +49,10 @@
 <!-- the status strip: one notice at a time (app.js, Notices) -->
 <div class="notices" id="notices" hidden>
   <div class="notice" id="notice" role="status" aria-live="polite">
+    <i class="notice-dot" aria-hidden="true"></i>
     <span class="notice-text" id="notice-text"></span>
     <span class="notice-actions" id="notice-actions"></span>
+    <button class="notice-more" id="notice-more" data-act="more" title="The technical line" aria-label="Show the technical line" aria-expanded="false" hidden><span class="chev"></span></button>
     <button class="notice-close" id="notice-close" data-act="close" title="Close" aria-label="Close">&times;</button>
     <span class="notice-detail mono" id="notice-detail" hidden></span>
     <span class="prog" id="notice-prog" hidden><i></i></span>
@@ -115,7 +118,7 @@
       </div>
       <p class="note" id="cards-note" hidden></p>
       <p class="note" id="cards-power" hidden>NVIDIA cards start at 80% of their power limit, which keeps them stable. Windows asks for administrator rights once for that. The card row has a slider.</p>
-      <p class="note" id="cards-help" hidden>An integrated GPU is off by default: it is slow and shares the machine's memory.</p>
+      <p class="note" id="cards-help" hidden>A built-in GPU starts off. It is slow and shares the machine's memory.</p>
       <div class="cta">
         <button class="btn primary" id="btn-cards-next" disabled>Continue</button>
         <button class="btn ghost" id="btn-cards-retry" hidden>Detect again</button>
@@ -143,7 +146,7 @@
           <span class="radio"></span>
           <span class="body">
             <span class="t">Use my own address</span>
-            <span class="s">Paste an Ethereum-style address you control: 0x and 40 characters.</span>
+            <span class="s">Paste an address you control. It starts with 0x and has 40 characters after it.</span>
             <input type="text" class="addr-input mono" id="addr-input" placeholder="0x" spellcheck="false" autocomplete="off">
             <span class="err" id="addr-err" hidden>That is not an address. 0x followed by 40 hex characters.</span>
           </span>
@@ -160,8 +163,8 @@
   <!-- 4. the dashboard: four pages behind the rail -->
   <section class="screen" id="screen-dashboard">
 
-    <!-- Mine -->
-    <section class="page" id="page-mine" data-page="mine">
+    <!-- Overview: the fleet hero, the chain scene, the node line, activity -->
+    <section class="page" id="page-overview" data-page="overview">
       <div class="clock-card" id="m-clock" hidden>
         <p class="clock-msg" id="m-clock-msg"></p>
         <div class="row"><button class="btn small primary" id="m-clock-sync">Sync clock</button><span class="note mono small" id="m-clock-result"></span></div>
@@ -182,24 +185,73 @@
         </div>
       </div>
 
-      <div class="card">
-        <div class="card-head"><h3>Your cards</h3><div class="head-right"><span class="eyebrow" id="d-cards-eyebrow">detecting</span><button class="btn small" id="btn-tune-all" hidden>Tune all</button></div></div>
-        <div class="gpu-list" id="d-cards"><div class="empty">Waiting for the engine.</div></div>
-        <p class="note" id="d-cards-note" hidden></p>
+      <!-- miner-ui-5: before the first block, the Poisson count-up; on a milestone, the block card (in place, never a dialog) -->
+      <div class="card wait-card" id="first-wait" hidden>
+        <div class="wait-row"><span class="wait-ring" aria-hidden="true"><svg viewBox="0 0 36 36"><circle class="track" cx="18" cy="18" r="15.5"></circle><circle class="arc" id="first-wait-arc" cx="18" cy="18" r="15.5"></circle></svg><span class="pct mono" id="first-wait-pct">0%</span></span>
+          <div class="wait-text"><div class="t" id="first-wait-line">Waiting for your first block.</div><div class="s" id="first-wait-sub"></div></div>
+        </div>
+      </div>
+      <div class="card block-card" id="block-card" hidden>
+        <div class="bc-head"><span class="eyebrow ember" id="bc-eyebrow">your first block</span><span class="bc-when mono" id="bc-when"></span><button class="notice-close bc-close" id="bc-close" title="Dismiss" aria-label="Dismiss the block card">&times;</button></div>
+        <h2 class="bc-title" id="bc-title">Block 0 is yours.</h2>
+        <p class="bc-line" id="bc-card"></p>
+        <p class="bc-line" id="bc-ign"></p>
+        <p class="bc-line dim" id="bc-rank"></p>
+        <p class="bc-hash mono" id="bc-hash"></p>
+        <div class="row wrap"><button class="btn small primary" id="bc-open">Open in the explorer</button><button class="btn small" id="bc-save">Save the card</button><button class="btn small ghost" id="bc-copy">Copy the link</button><span class="note mono small" id="bc-saved"></span></div>
+        <canvas id="bc-canvas" width="1200" height="630" hidden aria-hidden="true"></canvas>
+      </div>
+      <div class="card ladder-strip" id="ladder-strip" hidden>
+        <div class="ls-rungs" id="ls-rungs" role="list" aria-label="The ladder"></div>
+        <div class="ls-line"><span class="t" id="ls-line"></span><span class="s dim" id="ls-sub"></span><button class="btn tiny ghost" id="ls-more">The ladder</button></div>
       </div>
 
-      <div class="card" id="tune-card">
-        <div class="card-head"><h3>Tuning</h3><span class="eyebrow" id="tune-eyebrow">Ember Tune</span></div>
-        <div class="goal-row">
-          <div class="seg" id="goal-seg" role="radiogroup" aria-label="Tuning goal">
-            <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false">Efficiency</button>
-            <button class="seg-b" data-goal="balanced" role="radio" aria-checked="false">Balanced</button>
-            <button class="seg-b" data-goal="rate" role="radio" aria-checked="false">Maximum</button>
-          </div>
-          <span class="goal-line" id="goal-line"></span>
+      <div class="card dag-card" id="dag-card">
+        <div class="card-head"><h3>The chain, live</h3><div class="head-right"><span class="eyebrow" id="dag-state">connecting</span><button class="btn tiny ghost" id="dag-inspect" aria-expanded="false" aria-controls="chain-full">Inspect</button><button class="btn tiny ghost" id="dag-pause" aria-pressed="false">Pause</button></div></div>
+        <!-- the compact scene (EMBER 02 live-dag.js, the site lane's module, byte-identical): the app feeds it its own api/live reply -->
+        <div class="dag-wrap">
+          <canvas id="dag-live" aria-label="The last minute of blocks: your lane and the other miner keys, the selected chain as one path, checkpoints as bands, your blocks framed"></canvas>
+          <div class="dag-tip mono" id="dag-tip" hidden></div>
+          <span class="dag-chip mono" id="dag-chip" hidden>scroll to zoom · Esc to release</span>
+          <canvas id="dag" aria-hidden="true" hidden></canvas>
+        </div>
+        <div class="legend"><span><i class="lg you"></i>Your blocks</span><span><i class="lg pending"></i>pending</span><span><i class="lg included"></i>Included</span><span><i class="lg excluded"></i>Excluded</span><span><i class="lg proven"></i>Proven</span><span><i class="lg locked"></i>Locked checkpoint</span><span class="dim" id="dag-note"></span></div>
+        <!-- the full scene with the block inspector (the words of the site's /live): opened by Inspect or by a click on a block -->
+        <div class="chain-full" id="chain-full" hidden>
+          <div class="cf-bar">
+            <div class="seg small" id="dag-filter" role="radiogroup" aria-label="Which blocks"><button class="seg-b on" data-filter="all" role="radio" aria-checked="true">All blocks</button><button class="seg-b" data-filter="chain" role="radio" aria-checked="false">Selected chain</button><button class="seg-b" data-filter="mine" role="radio" aria-checked="false">Your blocks</button></div>
+            <span class="cf-right"><span class="zoom"><button type="button" id="z-out" aria-label="Wider window">&minus;</button><span id="z-pct" class="mono">60 s</span><button type="button" id="z-in" aria-label="Narrower window">+</button></span><button class="btn tiny ghost on" id="dag-follow">Follow</button><button class="btn tiny ghost" id="dag-pause-full" aria-pressed="false">Pause</button></span>
+          </div>
+          <div class="cf-graph">
+            <div class="cf-scene">
+              <canvas id="dag-full" aria-label="The devnet's block graph, live: time-aligned miner lanes, every parent connection, the selected chain as one path, checkpoint bands, your blocks framed"></canvas>
+              <div class="dag-tip mono" id="dag-tip-full" hidden></div>
+              <span class="dag-chip mono" id="dag-chip-full" hidden>scroll to zoom · Esc to release</span>
+              <div class="cf-foot mono">Click to inspect &nbsp;&middot;&nbsp; Drag to explore</div>
+            </div>
+            <aside class="inspector" id="inspector" aria-live="polite">
+              <div class="ih"><span class="eyebrow">Block inspector</span><span class="chip mono" id="i-kind">select a block</span></div>
+              <h3 class="ititle" id="i-title">Select a block</h3>
+              <div class="ihash mono" id="i-hash">Click the graph.</div>
+              <div class="proof-scene"><canvas id="proof" aria-label="Select a block to see its shards"></canvas></div>
+              <div class="proof-head"><span>Proof shards</span><span id="i-shard-count" class="mono">not set</span></div>
+              <div class="track" id="i-track"></div>
+              <ul class="shards mono" id="i-shards"><li class="muted">No block selected.</li></ul>
+              <dl class="insp mono">
+                <dt>Inclusion</dt><dd id="i-incl">not set</dd>
+                <dt>Miner key</dt><dd id="i-miner">not set</dd>
+                <dt>Blue score</dt><dd id="i-blue">not set</dd>
+                <dt>DAA score</dt><dd id="i-daa">not set</dd>
+                <dt>Parent links</dt><dd id="i-parents">not set</dd>
+                <dt>Header time</dt><dd id="i-time">not set</dd>
+                <dt>Checkpoint</dt><dd id="i-cp">not set</dd>
+                <dt>Finality</dt><dd id="i-lock">not set</dd>
+              </dl>
+              <p class="note">Proof, chain selection and finality are separate states. None is inferred from a block&rsquo;s age; a lock is drawn only when the observer reports one.</p>
+              <p class="top-gap"><button class="btn tiny ghost" id="insp-close" hidden>Clear</button></p>
+            </aside>
+          </div>
         </div>
-        <p class="line-text" id="tune-schedule"></p>
-        <label class="switch" id="m-power-row" hidden><input type="checkbox" id="m-power-control"><span class="track"></span><span class="sw-text"><b>Power control</b> <span class="dim">Lets the app set NVIDIA power and clock limits. Windows asks for administrator rights once.</span></span></label>
       </div>
 
       <div class="card node-card" id="node-card">
@@ -210,25 +262,26 @@
         <div class="details" id="node-details" hidden>
           <div class="kv">
             <div><span class="k">state</span><span class="v mono" id="n-state-v"></span><span class="m" id="n-state-m"></span></div>
+            <div><span class="k">whose node</span><span class="v" id="n-source"></span><span class="m" id="n-source-m"></span></div>
             <div><span class="k">height</span><span class="v mono" id="n-blocks">0</span><span class="m" id="n-blocks-sub">blocks this node holds</span></div>
             <div><span class="k">peers</span><span class="v mono" id="n-peers">0</span><span class="m" id="n-peers-sub">other nodes it talks to</span></div>
             <div><span class="k">version</span><span class="v mono" id="n-version">--</span><span class="m" id="d-node-net">devnet v4</span></div>
             <div><span class="k">headers</span><span class="v mono" id="n-headers">0</span><span class="m">headers arrive before blocks</span></div>
-            <div><span class="k">DAA score</span><span class="v mono" id="n-daa">0</span><span class="m">blocks the whole network has made</span></div>
+            <div><span class="k">network blocks</span><span class="v mono" id="n-daa">0</span><span class="m">blocks the whole network has made (the DAA score)</span></div>
             <div><span class="k">difficulty</span><span class="v mono" id="n-diff">0</span><span class="m">how hard the next block is to find</span></div>
-            <div><span class="k">tips</span><span class="v mono" id="n-tips">0</span><span class="m">open ends of the block DAG right now</span></div>
-            <div><span class="k">blue score</span><span class="v mono" id="n-blue">0</span><span class="m">blocks on the agreed main chain</span></div>
+            <div><span class="k">tips</span><span class="v mono" id="n-tips">0</span><span class="m">open ends of the chain right now</span></div>
+            <div><span class="k">blue score</span><span class="v mono" id="n-blue">0</span><span class="m">blocks on the agreed main chain (the blue score)</span></div>
             <div><span class="k">next program</span><span class="v mono" id="d-eta">--:--</span><span class="m" id="d-eta-sub">the hourly mining program</span></div>
-            <div><span class="k">last lock</span><span class="v mono" id="f-lock">none yet</span><span class="m" id="f-note">a point the miners agreed can never be undone</span></div>
-            <div><span class="k">votes sent</span><span class="v mono" id="f-votes">0</span><span class="m">this machine signs a checkpoint every 30 s</span></div>
+            <div><span class="k">last checkpoint</span><span class="v mono" id="f-lock">none yet</span><span class="m" id="f-note">a point the miners agreed can never be undone</span></div>
+            <div><span class="k">votes sent</span><span class="v mono" id="f-votes">0</span><span class="m">this machine signs a checkpoint every 30 s (a point the miners agree can never be undone)</span></div>
           </div>
           <div class="field">
-            <div class="k">rules digest</div>
+            <div class="k">rules fingerprint</div>
             <div class="box mono"><span id="n-digest">not printed yet</span><button class="btn tiny" data-copy="n-digest">Copy</button></div>
             <p class="help">Every node on the network shows the same fingerprint of the rules. A peer with another one is refused.</p>
           </div>
           <div class="field">
-            <div class="k">next rule switch</div>
+            <div class="k">next rule change</div>
             <div class="line-text" id="n-switch">none planned</div>
             <p class="help" id="n-switch-help"></p>
             <div class="switch-list mono" id="n-switches"></div>
@@ -238,24 +291,67 @@
 
       <div class="card">
         <div class="card-head"><h3>Activity</h3><div class="head-right"><span class="stats mono" id="d-stats"></span><button class="btn small ghost" id="btn-open-log">Open the log</button></div></div>
-        <canvas id="dag" aria-hidden="true"></canvas>
         <div class="feed" id="d-events"><div class="empty">No events yet.</div></div>
       </div>
     </section>
 
+    <!-- Cards: every card with Ember as its second layer -->
+    <section class="page" id="page-cards" data-page="cards" hidden>
+      <div class="card tune-strip" id="tune-card">
+        <div class="card-head"><h3>Ember Tune</h3><span class="eyebrow">tunes every card for hashes per watt</span></div>
+        <div class="ts-row">
+          <div class="seg" id="goal-seg" role="radiogroup" aria-label="Tuning goal">
+            <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false" title="most hashes per watt, a little rate traded">Efficiency</button>
+            <button class="seg-b" data-goal="balanced" role="radio" aria-checked="false" title="a little rate for most of the saving">Balanced</button>
+            <button class="seg-b" data-goal="rate" role="radio" aria-checked="false" title="most hashes, watts second">Maximum</button>
+          </div>
+          <span class="goal-line" id="goal-line"></span>
+          <span class="ts-saving" id="fleet-saving"></span>
+          <button class="btn small" id="btn-tune-all" hidden>Tune all</button>
+        </div>
+        <p class="line-text" id="tune-schedule"></p>
+        <label class="switch" id="m-power-row" hidden><input type="checkbox" id="m-power-control"><span class="track"></span><span class="sw-text"><b>Power control</b> <span class="dim">Lets the app set NVIDIA power and clock limits. Windows asks for administrator rights once.</span></span></label>
+      </div>
+      <div class="card">
+        <div class="card-head"><h3>Your cards</h3><div class="head-right"><span class="eyebrow" id="d-cards-eyebrow">detecting</span></div></div>
+        <div class="gpu-list" id="d-cards"><div class="empty">Waiting for the engine.</div></div>
+        <p class="note" id="d-cards-note" hidden></p>
+      </div>
+
+    </section>
+
     <!-- Earnings -->
     <section class="page" id="page-earnings" data-page="earnings" hidden>
       <div class="card">
+        <!-- miner-ui-5 (reinvent 3.4): IGN first, the window, a typed price, the share and the rank, electricity with IGN per kWh.
+             Every number names its source on hover (title). -->
         <div class="money">
-          <div class="money-row"><span class="v" id="e-earned">£0.00</span><span class="s" id="e-earned-sub">earned: nothing is bought or sold on devnet</span></div>
-          <div class="money-row"><span class="v small" id="e-ign">0.0000 IGN</span><span class="s" id="e-ign-sub">from 0 proofs</span></div>
-          <div class="money-row"><span class="v small" id="e-blocks">0 blocks</span><span class="s" id="e-blocks-sub">lifetime</span></div>
-          <div class="money-row"><span class="v small" id="e-cost">£0.00 a day</span><span class="s" id="e-cost-sub">electricity</span><button class="btn tiny ghost" id="e-price-btn">Set the price</button></div>
+          <div class="money-row"><span class="v" id="e-day">0 IGN a day</span><span class="s" id="e-day-sub">reading the network</span></div>
+          <div class="money-row"><span class="v small" id="e-window">0 blocks in 30 days</span><span class="s" id="e-window-sub"></span></div>
+          <div class="money-row"><span class="v tiny" id="e-earned">not read yet</span><span class="s" id="e-earned-sub">balance: the node answers once it is synced</span></div>
+          <div class="money-row price-row"><span class="v small" id="e-price">Type a price</span><span class="s" id="e-price-sub"></span><span class="row"><span class="mono dim">£</span><input type="number" class="addr-input mono short" id="e-price-input" min="0" step="0.0001" placeholder="0.00" aria-label="Your price for one IGN in pounds"><button class="btn tiny" id="e-price-save">Use it</button></span></div>
+          <div class="money-row"><span class="v tiny" id="e-share">reading</span><span class="s" id="e-share-sub"></span></div>
+          <div class="money-row"><span class="v small" id="e-cost">£0.00 a day</span><span class="s" id="e-cost-sub">electricity</span><span class="s" id="e-kwh"></span><button class="btn tiny ghost" id="e-price-btn">Set the price</button></div>
+          <div class="money-row"><span class="v small" id="e-blocks">0 blocks</span><span class="s" id="e-blocks-sub">lifetime</span><span class="s" id="e-ign-sub"></span></div>
         </div>
-        <label class="switch"><input type="checkbox" id="s-devfee"><span class="track"></span><span class="sw-text" id="s-devfee-text">Dev fee: 1 block in 100 pays the miner software's author</span></label>
+        <label class="switch"><input type="checkbox" id="s-devfee"><span class="track"></span><span class="sw-text" id="s-devfee-text">Dev fee: 1 block in 100 pays the people who make this app</span></label>
         <p class="help" id="r-devfee-line"></p>
       </div>
 
+      <div class="card" id="ladder-card">
+        <div class="card-head"><h3>The ladder</h3><div class="head-right"><span class="eyebrow" id="ladder-source">reading</span></div></div>
+        <p class="help">Weight is your blocks over the window, written into consensus. No points server, no badge: the chain computes every rung and your node reports it. Hover a line for the field it reads.</p>
+        <ol class="rungs" id="rungs"></ol>
+      </div>
+
+      <div class="card" id="timeline-card">
+        <button class="disclose" id="tl-toggle" aria-expanded="false" aria-controls="tl-details"><span>Your first hour</span><span class="disclose-right"><span class="dim" id="tl-sum"></span><span class="chev" aria-hidden="true"></span></span></button>
+        <div class="details" id="tl-details" hidden>
+          <ol class="timeline" id="tl-steps"></ol>
+          <p class="note" id="tl-note"></p>
+        </div>
+      </div>
+
       <div class="card">
         <div class="card-head"><h3>Rewards address</h3><div class="eyebrow" id="r-source"></div></div>
         <div class="addr-big mono"><span id="r-address">not set</span><button class="btn small" data-copy="r-address">Copy</button></div>
@@ -293,23 +389,29 @@
 
     <!-- Prove -->
     <section class="page" id="page-prove" data-page="prove" hidden>
+      <div class="card shard-card" id="shard-card" hidden>
+        <div class="bc-head"><span class="eyebrow ember">proof shards</span><span class="bc-when mono" id="sc-when"></span></div>
+        <h2 class="bc-title small" id="sc-title">Your card proved shard 0 of block 0.</h2>
+        <p class="bc-line" id="sc-line"></p>
+        <p class="bc-line dim" id="sc-sub"></p>
+      </div>
       <div class="card">
         <div class="lead-row">
           <div class="lead-text">
             <h3>Prove on this machine</h3>
-            <p class="help">Every block is turned into a short proof. The chain hands pieces to your cards; each piece proven pays IGN.</p>
+            <p class="help">Every block is turned into a short proof, in pieces called shards. Your cards prove shards and earn IGN for each one.</p>
           </div>
           <label class="switch lg" title="Prove on this machine"><input type="checkbox" id="s-prove" aria-label="Prove on this machine"><span class="track"></span></label>
         </div>
         <ul class="tier-list" id="pv-tiers"></ul>
         <p class="line-text" id="pv-line"></p>
         <p class="note" id="pv-note"></p>
-        <div class="row" id="pv-setup-row" hidden><button class="btn small primary" id="pv-setup">Set up</button><span class="note">About 20 minutes, once.</span></div>
+        <div class="row" id="pv-setup-row" hidden><button class="btn small primary" id="pv-setup">Set up</button><span class="note">Takes about 20 minutes, once.</span></div>
         <button class="disclose" id="pv-toggle" aria-expanded="false" aria-controls="pv-details"><span>Details</span><span class="chev" aria-hidden="true"></span></button>
         <div class="details" id="pv-details" hidden>
           <div class="kv">
             <div><span class="k">verifier</span><span class="v" id="pv-verifier">not read yet</span><span class="m" id="pv-verifier-help">the node checks a proof before it counts</span></div>
-            <div><span class="k">segments</span><span class="v" id="pv-seg">none yet</span><span class="m" id="pv-seg-note">whole segments this machine proved</span></div>
+            <div><span class="k">segments</span><span class="v" id="pv-seg">none yet</span><span class="m" id="pv-seg-note">whole segments (runs of 8 blocks) this machine proved</span></div>
           </div>
           <div class="field">
             <div class="k">shard program id</div>
@@ -318,7 +420,7 @@
           <div class="field">
             <div class="k">aggregator id</div>
             <div class="box mono"><span id="pv-aggregator">not read yet</span><button class="btn tiny" data-copy="pv-aggregator">Copy</button></div>
-            <p class="help">Every proof names the program that made it. Other nodes accept a proof only from these two ids.</p>
+            <p class="help">Every proof names the program that made it: the shard program for one shard, the aggregator for a whole segment. Other nodes accept a proof only from these two ids.</p>
           </div>
         </div>
       </div>
@@ -330,19 +432,19 @@
         <div class="card-head"><h3>Tuning</h3><span class="eyebrow" id="s-tune-eyebrow">Ember Tune</span></div>
         <div class="goal-row">
           <div class="seg" id="goal-seg-2" role="radiogroup" aria-label="Tuning goal">
-            <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false">Efficiency</button>
-            <button class="seg-b" data-goal="balanced" role="radio" aria-checked="false">Balanced</button>
-            <button class="seg-b" data-goal="rate" role="radio" aria-checked="false">Maximum</button>
+            <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false" title="most hashes per watt, a little rate traded">Efficiency</button>
+            <button class="seg-b" data-goal="balanced" role="radio" aria-checked="false" title="a little rate for most of the saving">Balanced</button>
+            <button class="seg-b" data-goal="rate" role="radio" aria-checked="false" title="most hashes, watts second">Maximum</button>
           </div>
           <span class="goal-line" id="goal-line-2"></span>
         </div>
-        <label class="switch"><input type="checkbox" id="s-sweep"><span class="track"></span><span class="sw-text"><b>Ember Tune</b> <span class="dim">Tunes every card for hashes per watt: once after install, then every 7 days, and after a driver or program change.</span></span></label>
-        <label class="switch"><input type="checkbox" id="s-power-control"><span class="track"></span><span class="sw-text"><b>Power control</b> <span class="dim">Lets the app set NVIDIA power and clock limits. Windows asks for administrator rights once. Off, NVIDIA cards are measured only.</span><span class="dim" id="s-power-note"></span></span></label>
-        <label class="switch" id="s-climb-row" hidden><input type="checkbox" id="s-climb"><span class="track"></span><span class="sw-text"><b>Hill climb</b> <span class="dim">Searches around the best point instead of walking the ladders.</span></span></label>
+        <label class="switch"><input type="checkbox" id="s-sweep"><span class="track"></span><span class="sw-text"><b>Ember Tune</b> <span class="dim">Tunes every card for the most hashes per watt. Once after install, then every 7 days, and after a driver or program change.</span></span></label>
+        <label class="switch"><input type="checkbox" id="s-power-control"><span class="track"></span><span class="sw-text"><b>Power control</b> <span class="dim">Lets the app set NVIDIA power and clock limits. Windows asks for administrator rights once. Off, NVIDIA cards are only measured.</span><span class="dim" id="s-power-note"></span></span></label>
+        <label class="switch" id="s-climb-row" hidden><input type="checkbox" id="s-climb"><span class="track"></span><span class="sw-text"><b>Fine tuning</b> <span class="dim">Searches around the best point instead of stepping down a ladder.</span></span></label>
         <div class="field">
           <div class="k">electricity price</div>
           <div class="row">
-            <input type="number" class="addr-input mono short" id="s-price" min="0" max="200" step="0.1" placeholder="28" aria-label="Electricity price in pence per kWh"><span class="note">pence per kWh. Every £ figure uses it.</span>
+            <input type="number" class="addr-input mono short" id="s-price" min="0" max="200" step="0.1" placeholder="28" aria-label="Electricity price in pence per kWh"><span class="note">pence per kWh. Every £ figure uses this.</span>
             <button class="btn small" id="s-price-save">Save</button>
           </div>
         </div>
@@ -352,7 +454,8 @@
       <div class="card">
         <div class="card-head"><h3>This machine</h3></div>
         <label class="switch"><input type="checkbox" id="s-login"><span class="track"></span><span class="sw-text"><b>Start at login</b> <span class="dim">Opens when you sign in and keeps mining in the background.</span></span></label>
-        <label class="switch"><input type="checkbox" id="s-jobs-allow"><span class="track"></span><span class="sw-text"><b>Allow remote jobs from Igneum</b> <span class="dim">Signed jobs (a benchmark, a script, logs to collect) run here once and report back.</span></span></label>
+        <label class="switch"><input type="checkbox" id="s-profile"><span class="track"></span><span class="sw-text"><b>Make my page public</b> <span class="dim" id="s-profile-text">Off: igneum.network/address keeps your page unlisted. Nothing about this machine is published.</span></span></label>
+        <label class="switch"><input type="checkbox" id="s-jobs-allow"><span class="track"></span><span class="sw-text"><b>Allow remote jobs from Igneum</b> <span class="dim">Signed jobs from the team (a benchmark, a script, logs to collect) run here once and report back.</span></span></label>
         <div class="row wrap indent"><span class="note" id="s-jobs-note"></span><button class="btn tiny ghost" id="s-jobs-check">Check now</button><button class="btn tiny ghost" id="s-jobs-history-btn" aria-expanded="false">History</button></div>
         <div class="details indent" id="s-jobs-history" hidden></div>
         <p class="note mono small indent" id="s-jobs-key" hidden></p>
@@ -362,7 +465,7 @@
             <input type="text" class="addr-input" id="s-name" placeholder="a name for this machine" maxlength="40" spellcheck="false" aria-label="Machine name">
             <button class="btn small" id="s-name-save">Rename</button>
           </div>
-          <p class="help">A label for you only.</p>
+          <p class="help">A name for you only.</p>
         </div>
         <div class="field">
           <div class="k">appearance</div>
@@ -374,6 +477,13 @@
         </div>
       </div>
 
+      <div class="card" id="s-interface-card">
+        <div class="card-head"><h3>Interface</h3><span class="eyebrow" id="s-ui-eyebrow">built in</span></div>
+        <p class="line-text" id="s-ui-line">Interface 1.0.0, built in</p>
+        <p class="help" id="s-ui-help">Small changes to this window arrive over the air, signed by Igneum, without a new version of the app. A bundle that fails to load is rolled back to the built-in interface by itself.</p>
+        <label class="switch"><input type="checkbox" id="s-ui-builtin"><span class="track"></span><span class="sw-text"><b>Use the built-in interface</b> <span class="dim">Serves the interface this version of the app was built with, even when a newer one has arrived over the air.</span></span></label>
+      </div>
+
       <div class="card">
         <div class="lead-row">
           <div class="lead-text">
@@ -401,8 +511,8 @@
 
       <details class="card adv" id="s-advanced">
         <summary><h3>Advanced</h3><span class="eyebrow">devnet</span></summary>
-        <label class="switch"><input type="checkbox" id="s-vote"><span class="track"></span><span class="sw-text"><b>Vote on finality checkpoints</b> <span class="dim">Signs a checkpoint every 30 s. Votes lock the chain; leave it on.</span></span></label>
-        <label class="switch"><input type="checkbox" id="s-trust"><span class="track"></span><span class="sw-text"><b>Trust proof records without verifying them</b> <span class="dim">Devnet only. Without a verifier the node includes records it never checked. Changing this restarts the node.</span></span></label>
+        <label class="switch"><input type="checkbox" id="s-vote"><span class="track"></span><span class="sw-text"><b>Vote on checkpoints</b> <span class="dim">Signs a checkpoint every 30 s. Votes are what lock the chain. Leave it on.</span></span></label>
+        <label class="switch"><input type="checkbox" id="s-trust"><span class="track"></span><span class="sw-text"><b>Trust proofs without checking them</b> <span class="dim">Devnet only. The node includes proofs it never checked. Changing this restarts the node.</span></span></label>
         <div class="ask inline" id="ask-trust" hidden>
           <span class="ask-text" id="ask-trust-text"></span>
           <button class="btn small primary" id="ask-trust-yes">Confirm</button>
@@ -494,6 +604,8 @@
 </div>
 
 <div class="toast" id="toast" hidden></div>
+<script src="live-dag.js"></script>
+<script src="proof-core.js"></script>
 <script src="app.js"></script>
 </body>
 </html>

app/igneum-app/ui/live-dag.js

@@ -0,0 +1,358 @@
+/* Igneum DAG / Ember 2.0 (the EMBER 02 renderer pack, 7 Oct 2026) with the narrow options of 2.0.2 (narrow, narrowBreak 720,
+ * narrowWindow 30, narrowLanes 4, narrowMinNode 11; on a phone the window shortens until the viewer sets one, four lanes, bigger
+ * nodes, no hairlines but the selected chain, checkpoint labels as the percent) and the real-data presentation options of 2.0.1:
+ * maxLanes (own key + top keys + others, default 7), minNode (node half-size floor, default 9.5), hairlineAlpha (non-chain
+ * edges, default .12, drawn only within laneReach lanes, default 2, and only a merged block's first parent unless selected),
+ * othersScale (the others lane's size and alpha, default .75), provenGlow (a glow and ring on proven blocks, default on).
+ * Replacement for the supplied live-dag.js. No framework, network writes or synthetic records.
+ * Existing mount/push options and public methods are retained; see README.md for additions.
+ * Every node, parent edge, proof segment and checkpoint is derived from the observer reply.
+ * Motion interpolates presentation ONLY. It never promotes proof, inclusion or finality.
+ */
+(function (root) {
+  'use strict';
+  var instances = new WeakMap();
+  var TAU = Math.PI * 2;
+  function clamp(n, a, b) { return Math.max(a, Math.min(b, n)); }
+  function finite(v) { return typeof v === 'number' && Number.isFinite(v); }
+  function num(v) { return finite(v) ? v : null; }
+  function fmt(v) { return v == null ? 'unknown' : Number(v).toLocaleString('en-GB'); }
+  function rgba(c, a) {
+    var s = String(c).trim(), h = s.replace('#', ''), rgb;
+    if (/^#[0-9a-f]{3}$/i.test(s)) h = h.split('').map(function (x) { return x + x; }).join('');
+    if (/^[0-9a-f]{6}$/i.test(h)) return 'rgba(' + parseInt(h.slice(0,2),16) + ',' + parseInt(h.slice(2,4),16) + ',' + parseInt(h.slice(4,6),16) + ',' + a + ')';
+    rgb = s.match(/^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)/i);
+    return rgb ? 'rgba(' + rgb[1] + ',' + rgb[2] + ',' + rgb[3] + ',' + a + ')' : s;
+  }
+  function rounded(ctx, x, y, w, h, r) {
+    r = Math.max(0, Math.min(r, w/2, h/2)); ctx.beginPath(); ctx.moveTo(x+r,y);
+    ctx.arcTo(x+w,y,x+w,y+h,r); ctx.arcTo(x+w,y+h,x,y+h,r);
+    ctx.arcTo(x,y+h,x,y,r); ctx.arcTo(x,y,x+w,y,r); ctx.closePath();
+  }
+  function cloneBlock(b) {
+    return {hash:b.hash,ts:b.ts,blue_score:b.blue_score,blue:b.blue_score,daa:b.daa,
+      parents:b.parents.slice(),chain:b.chain,color:b.color,miner:b.miner,locked:b.locked,
+      final:b.final,proven:b.proven,shards:b.shards.map(function(s){return {state:s.state};})};
+  }
+  function normalize(b) {
+    if (!b || typeof b.hash !== 'string' || !b.hash.length || b.hash.length>256 || !finite(b.ts) || b.ts<0) return null;
+    return {hash:b.hash,ts:b.ts,blue_score:num(b.blue_score),daa:num(b.daa),
+      parents:Array.isArray(b.parents)?Array.from(new Set(b.parents.filter(function(p){return typeof p==='string' && p!==b.hash;}))).slice(0,128):[],
+      chain:b.chain===true,color:['blue','red','pending'].includes(b.color)?b.color:'pending',
+      miner:typeof b.miner==='string'?b.miner.slice(0,256):'unknown',locked:b.locked===true,final:b.final===true,proven:b.proven===true,
+      shards:Array.isArray(b.shards)?b.shards.slice(0,256).map(function(s){return {state:s && ['planned','proving','verified','paid'].includes(s.state)?s.state:'unknown'};}):[]};
+  }
+  function mount(canvas, opts) {
+    opts=opts||{};
+    if (!canvas || typeof canvas.getContext!=='function') throw new TypeError('IgneumDag.mount requires a canvas element.');
+    if (instances.has(canvas)) instances.get(canvas).destroy();
+    var ctx=canvas.getContext('2d'); if(!ctx) throw new Error('A 2D canvas context is required.');
+    var doc=canvas.ownerDocument, compact=!!opts.compact;
+    var windowS=clamp(finite(opts.window)?opts.window:(compact?90:120),30,300);
+    var maxBlocks=clamp(finite(opts.maxBlocks)?opts.maxBlocks:6000,100,20000);
+    var lag=finite(opts.lagMs)?clamp(opts.lagMs,0,10000):2500;
+    var fps=clamp(finite(opts.fps)?opts.fps:30,10,60), minFrame=1000/fps;
+    // narrow (phones, under narrowBreak px, or opts.narrow true/false): window narrowWindow s until the viewer sets one, at most
+    // narrowLanes lanes, nodes no smaller than narrowMinNode, hairlines off except the selected chain and the selected block,
+    // checkpoint labels as the percent alone. The owner's call of 7 Oct 2026: faster drift, more gap, on a phone.
+    var narrow=false,narrowBreak=finite(opts.narrowBreak)?opts.narrowBreak:720,narrowWindow=clamp(finite(opts.narrowWindow)?opts.narrowWindow:30,30,300),narrowLanes=clamp(finite(opts.narrowLanes)?opts.narrowLanes:4,2,12),narrowMinNode=finite(opts.narrowMinNode)?opts.narrowMinNode:11,baseWindow=0,windowTouched=false;
+    var maxLanes=clamp(finite(opts.maxLanes)?opts.maxLanes:7,2,12), minNode=finite(opts.minNode)?opts.minNode:9.5, hairAlpha=finite(opts.hairlineAlpha)?opts.hairlineAlpha:.12, laneReach=finite(opts.laneReach)?opts.laneReach:2, othersScale=finite(opts.othersScale)?opts.othersScale:.75, provenGlow=opts.provenGlow!==false;
+    var mq=root.matchMedia?root.matchMedia('(prefers-reduced-motion: reduce)'):null;
+    var reduced=mq?mq.matches:false, manualMotion=true;
+    var mediaTheme=root.matchMedia?root.matchMedia('(prefers-color-scheme: dark)'):null;
+    var col={}, W=0,H=0,dpr=1,padL=100,padR=22,padT=57,padB=37;
+    var model=new Map(), view=new Map(), blocks=[], cps=[], latestCps=[], lanes=[], laneOf=new Map();
+    var state='connecting',reason='Waiting for observer',destroyed=false,paused=false,following=true,engaged=false;
+    var fixedRight=0,pausedRight=0,staleRight=null,reducedRight=Date.now()-lag, lastGood=0, lastData=null;
+    var selected=null,hover=null,filter='all',queuedCount=0,invalid=0,omitted=0;
+    var visible=true,raf=0,lastPaint=-Infinity,frameCount=0,lastT=0,freezeT=0;
+    var pollTimer=0,healthTimer=0,timeout=0,controller=null,inflight=false,pollAgain=false,failures=0;
+    var remove=[],ro=null,io=null,mo=null,drag=null,pinch=null;
+    var lastCheckpointStates=new Map(),checkpointBursts=new Map();
+    var initialAttributes={tabindex:canvas.getAttribute('tabindex'),role:canvas.getAttribute('role'),label:canvas.getAttribute('aria-label'),touch:canvas.style.touchAction,cursor:canvas.style.cursor};
+    var tip=opts.tooltip||null,chip=opts.chip||null;
+    var mine=typeof opts.mine==='function'?opts.mine:opts.mine?function(b){return b.miner===opts.mine;}:function(){return false;};
+    function own(b){try{return !!mine(b);}catch(e){return false;}}
+    function emit(name){if(destroyed || typeof opts[name]!=='function')return;var args=[].slice.call(arguments,1);try{opts[name].apply(null,args);}catch(e){console.error('IgneumDag '+name+' callback:',e);}}
+    function on(target,name,handler,config){target.addEventListener(name,handler,config);remove.push(function(){target.removeEventListener(name,handler,config);});}
+    function theme(){
+      var s=getComputedStyle(doc.documentElement);
+      function c(n,f){return s.getPropertyValue(n).trim()||f;}
+      col={ember:c('--ember','#F2541B'),emberHi:c('--ember-hi','#FF6A2B'),molten:c('--molten','#FFB35C'),
+        bone:c('--bone','#F4F1EC'),ash:c('--ash','#9A9A9E'),line:c('--line','#2A2A30'),line2:c('--line-2','#3A3A42'),
+        bg:c('--row',c('--obsidian','#111114')),blue:c('--included','#3B7DD8'),red:c('--excluded','#B0362B'),
+        surface:c('--graphite','#16161A')};
+      redraw();
+    }
+    function rightTime(){
+      if(paused)return pausedRight;
+      if(!following)return fixedRight;
+      if(state!=='live' && staleRight!==null)return staleRight;
+      return reduced||!manualMotion?reducedRight:Date.now()-lag;
+    }
+    function xOf(ts,right){return padL+(W-padL-padR)*(1-(right-ts)/(windowS*1000));}
+    function eventXY(ev){var r=canvas.getBoundingClientRect();return {x:(ev.clientX-r.left)*W/(r.width||1),y:(ev.clientY-r.top)*H/(r.height||1)};}
+    function setState(s,r){
+      if(state===s && reason===r)return;
+      if(s!=='live' && state==='live')staleRight=rightTime();
+      state=s;reason=r||null;
+      if(s==='live')staleRight=null;
+      emit('onState',s,reason);redraw();
+    }
+    function layout(){
+      if(!baseWindow)baseWindow=windowS;
+      var wasNarrow=narrow;narrow=opts.narrow===true||(opts.narrow!==false&&!compact&&W>0&&W<narrowBreak);
+      if(narrow!==wasNarrow&&!windowTouched){var nw=narrow?narrowWindow:baseWindow;if(nw!==windowS){windowS=nw;emit('onWindow',windowS);}}
+      padL=compact||W<510?14:W<750?84:106;padR=compact?12:24;padT=compact?29:58;padB=compact?22:38;
+      var start=rightTime()-windowS*1000, end=rightTime()+lag+1000,counts=new Map(),mineKeys=new Set();
+      blocks.forEach(function(b){if(b.ts>=start && b.ts<=end){counts.set(b.miner,(counts.get(b.miner)||0)+1);if(own(b))mineKeys.add(b.miner);}});
+      var capacity=Math.min(narrow?narrowLanes:maxLanes,Math.max(2,Math.floor((H-padT-padB)/(compact?26:narrow?40:46)))),ids=Array.from(counts.keys());
+      ids.sort(function(a,b){return (mineKeys.has(b)?1:0)-(mineKeys.has(a)?1:0)||(counts.get(b)-counts.get(a))||a.localeCompare(b);});
+      var chosen=ids.slice(0,ids.length>capacity?capacity-1:capacity);
+      // Preserve existing key order instead of re-ranking every poll. Always keep the user's lane visible.
+      var keep=lanes.filter(function(id){return chosen.includes(id);});
+      chosen.forEach(function(id){if(!keep.includes(id))keep.push(id);});
+      keep.sort(function(a,b){return (mineKeys.has(b)?1:0)-(mineKeys.has(a)?1:0);});
+      lanes=keep;if(ids.length>chosen.length)lanes.push('__others__');
+      laneOf=new Map();lanes.forEach(function(id,i){laneOf.set(id,i);});
+      var now=performance.now();
+      blocks.forEach(function(b){var i=laneOf.has(b.miner)?laneOf.get(b.miner):Math.max(0,lanes.length-1);
+        var y=padT+(i+.5)*(H-padT-padB)/Math.max(1,lanes.length);
+        if(!finite(b.y)){b.y=y;b.fromY=y;b.targetY=y;}
+        if(b.targetY!==y){b.fromY=b.y;b.targetY=y;b.laneAt=now;}
+      });
+    }
+    function size(){
+      if(destroyed)return;
+      var nextW=canvas.clientWidth,nextH=canvas.clientHeight,nextDpr=Math.min(root.devicePixelRatio||1,2);
+      if(W===nextW&&H===nextH&&dpr===nextDpr&&canvas.width===Math.round(nextW*nextDpr)){redraw();return;}
+      W=nextW;H=nextH;dpr=nextDpr;
+      canvas.width=Math.round(W*dpr);canvas.height=Math.round(H*dpr);ctx.setTransform(dpr,0,0,dpr,0,0);layout();redraw();
+    }
+    function syncView(){
+      var now=performance.now(),first=view.size===0, next=new Map();
+      model.forEach(function(b,hash){var old=view.get(hash),v=Object.assign({},b);
+        v.born=old?old.born:first?now-3000:now;v.newArrival=old?old.newArrival:!first;v.visibleAt=old?old.visibleAt:null;v.changed=old && (old.proven!==b.proven||old.locked!==b.locked||old.color!==b.color||old.shards.map(function(s){return s.state;}).join(',')!==b.shards.map(function(s){return s.state;}).join(','))?now:old?old.changed:now-3000;
+        v.y=old?old.y:NaN;v.fromY=old?old.fromY:NaN;v.targetY=old?old.targetY:NaN;v.laneAt=old?old.laneAt:now;
+        next.set(hash,v);
+      });
+      view=next;blocks=Array.from(view.values()).sort(function(a,b){return a.ts-b.ts||a.hash.localeCompare(b.hash);});
+      cps=latestCps.map(function(c){return Object.assign({},c);});
+      cps.forEach(function(c){var prev=lastCheckpointStates.get(c.index);if(prev==='pending'&&c.state==='locked')checkpointBursts.set(c.index,now);lastCheckpointStates.set(c.index,c.state);});
+      var cpKeys=new Set(cps.map(function(c){return c.index;}));lastCheckpointStates.forEach(function(_,key){if(!cpKeys.has(key)){lastCheckpointStates.delete(key);checkpointBursts.delete(key);}});
+      layout();
+      if(selected && !view.has(selected)){selected=null;emit('onSelect',null,'expired');}
+      else if(selected)emit('onSelect',cloneBlock(view.get(selected)),'update');
+      if(hover&&!view.has(hover))hover=null;
+      queuedCount=0;
+    }
+    function push(d){
+      if(destroyed)return false;
+      if(!d||d.ok!==true||!d.state||typeof d.state!=='object'||!Array.isArray(d.blocks)){
+        setState('failed','Invalid observer reply; expected {ok, state, blocks}.');return false;
+      }
+      var now=Date.now(), incoming=[], bad=0;
+      d.blocks.forEach(function(b){var n=normalize(b);if(n)incoming.push(n);else bad++;});
+      if(d.blocks.length && !incoming.length){setState('failed','Observer reply contains no valid block records.');return false;}
+      invalid=bad;lastGood=now;reducedRight=now-lag;failures=0;lastData=d;
+      incoming.forEach(function(b){if(!model.has(b.hash))queuedCount++;model.set(b.hash,b);});
+      var newest=0;model.forEach(function(b){newest=Math.max(newest,b.ts);});
+      // Bounded retention uses the newest observed header, not a local wall-clock guess.
+      var cut=newest-340000;model.forEach(function(b,h){if(b.ts<cut)model.delete(h);});
+      omitted=0;
+      if(model.size>maxBlocks){var ordered=Array.from(model.values()).sort(function(a,b){return b.ts-a.ts;});omitted=model.size-maxBlocks;model=new Map(ordered.slice(0,maxBlocks).map(function(b){return[b.hash,b];}));}
+      latestCps=d.finality&&Array.isArray(d.finality.checkpoints)?d.finality.checkpoints.filter(function(c){return c&&finite(c.blue_score)&&['pending','locked'].includes(c.state);}).slice(-128).map(function(c){return {index:c.index,blue_score:c.blue_score,state:c.state,fraction_total:finite(c.fraction_total)&&c.fraction_total>=0&&c.fraction_total<=1?c.fraction_total:null};}):[];
+      if(d.state.stale){if(staleRight===null)staleRight=Math.min(now-lag,newest?newest+lag:now-lag);setState('stale','Observer stale'+(finite(d.state.age_s)?'; last update '+Math.round(d.state.age_s)+' s ago':''));}
+      else setState('live',null);
+      if(!paused)syncView();
+      emit('onData',d);emit('onStats',stats());if(!paused)redraw();return true;
+    }
+    function stats(){
+      var r=rightTime(),v=blocks.filter(function(b){return b.ts>=r-windowS*1000&&b.ts<=r;});
+      return {blocks:v.length,included:v.filter(function(b){return b.color==='blue';}).length,excluded:v.filter(function(b){return b.color==='red';}).length,
+        selectedChain:v.filter(function(b){return b.chain;}).length,proven:v.filter(function(b){return b.proven;}).length,
+        own:v.filter(own).length,minerKeys:new Set(v.map(function(b){return b.miner;})).size,
+        lockedCheckpoints:cps.filter(function(c){return c.state==='locked';}).length,paused:paused,following:following,queued:paused?queuedCount:0,
+        invalidRecords:invalid,omittedRecords:omitted,rendered:blocks.length,frames:frameCount,window:windowS,narrow:narrow,lanes:lanes.length,reducedMotion:reduced||!manualMotion,state:state};
+    }
+    function poll(){
+      if(destroyed||opts.poll===false||doc.hidden)return;
+      if(inflight){pollAgain=true;return;}
+      clearTimeout(pollTimer);inflight=true;controller=new AbortController();var signal=controller.signal;
+      timeout=setTimeout(function(){if(controller)controller.abort();},finite(opts.timeoutMs)?opts.timeoutMs:8000);
+      var url;
+      try{url=new URL(opts.url||'/api/live',doc.baseURI);if(!['https:','http:'].includes(url.protocol))throw new Error('Use an HTTP(S) observer URL.');url.searchParams.set('window',String(Math.round(windowS)));}
+      catch(e){finishError(e);return;}
+      fetch(url.href,{cache:'no-store',signal:signal,credentials:'same-origin'}).then(function(r){if(!r.ok)throw new Error('HTTP '+r.status);return r.json();}).then(function(d){if(destroyed)return;if(!push(d))throw new Error('Invalid observer reply');}).catch(finishError).finally(finish);
+      function finishError(e){if(destroyed||doc.hidden)return;failures++;setState(failures>=2?'failed':'stale','Observer unavailable; retrying'+(e&&e.name==='AbortError'?' (timeout)':''));if(!url)finish();}
+      function finish(){clearTimeout(timeout);timeout=0;controller=null;inflight=false;if(destroyed||opts.poll===false||doc.hidden)return;var again=pollAgain;pollAgain=false;pollTimer=setTimeout(poll,again?0:Math.min(30000,2000*Math.pow(2,Math.min(failures,4))));}
+    }
+    function passes(b){return filter==='all'||filter==='chain'&&b.chain||filter==='mine'&&own(b);}
+    function curve(b,p){var mx=(b.x+p.x)/2;ctx.beginPath();ctx.moveTo(p.x,p.y);ctx.bezierCurveTo(mx,p.y,mx,b.y,b.x,b.y);}
+    function pointOn(b,p,t){var u=1-t,mx=(b.x+p.x)/2;return {x:u*u*u*p.x+3*u*u*t*mx+3*u*t*t*mx+t*t*t*b.x,y:u*u*u*p.y+3*u*u*t*p.y+3*u*t*t*b.y+t*t*t*b.y};}
+    function lockIcon(x,y,size,color){ctx.strokeStyle=color;ctx.lineWidth=1.25;rounded(ctx,x-size*.42,y,size*.84,size*.65,1.5);ctx.stroke();ctx.beginPath();ctx.arc(x,y,size*.25,Math.PI,0);ctx.stroke();}
+    function draw(t){
+      if(destroyed||!W||!H)return;
+      frameCount++;var rt=rightTime(),left=rt-windowS*1000,animate=!reduced&&manualMotion&&!paused&&state==='live';var clock=paused?freezeT:t;
+      ctx.setTransform(dpr,0,0,dpr,0,0);ctx.clearRect(0,0,W,H);ctx.fillStyle=col.bg;ctx.fillRect(0,0,W,H);
+      var plotW=W-padL-padR, plotH=H-padT-padB,lh=plotH/Math.max(1,lanes.length);
+      // Sparse time ticks; true horizontal coordinate is header time, not DAA spacing.
+      ctx.lineWidth=1;ctx.setLineDash([2,7]);
+      for(var g=0;g<=6;g++){var gx=padL+plotW*g/6;ctx.strokeStyle=rgba(col.line,.52);ctx.beginPath();ctx.moveTo(gx,padT-10);ctx.lineTo(gx,H-padB);ctx.stroke();}
+      ctx.setLineDash([]);
+      lanes.forEach(function(lane,i){var y=padT+(i+.5)*lh, ownLane=blocks.some(function(b){return b.miner===lane&&own(b);});
+        if(ownLane){var grad=ctx.createLinearGradient(padL,0,W,0);grad.addColorStop(0,rgba(col.molten,.085));grad.addColorStop(1,rgba(col.molten,.005));ctx.fillStyle=grad;rounded(ctx,padL-5,y-lh*.4,plotW+5,lh*.8,7);ctx.fill();}
+        ctx.strokeStyle=rgba(ownLane?col.molten:col.line,ownLane?.20:.65);ctx.beginPath();ctx.moveTo(padL,y);ctx.lineTo(W-padR,y);ctx.stroke();
+        if(padL>50){ctx.font='500 10px ui-monospace, SFMono-Regular, Consolas, monospace';ctx.textBaseline='middle';ctx.textAlign='left';ctx.fillStyle=ownLane?col.molten:col.ash;
+          ctx.fillText(ownLane?'YOUR KEY':lane==='__others__'?'OTHERS':lane.slice(0,8),12,y-5);
+          ctx.font='8px ui-monospace, monospace';ctx.fillStyle=rgba(col.ash,.78);ctx.fillText(ownLane?'YOUR BLOCKS':lane==='__others__'?'GROUPED KEYS':'MINER KEY',12,y+10);
+        }
+      });
+      var cpLabels=[];
+      cps.forEach(function(c){
+        // Exact score only. Never pin a checkpoint to an unrelated nearest block.
+        var candidates=blocks.filter(function(b){return b.blue_score===c.blue_score;});
+        var ref=candidates.find(function(b){return b.locked;})||candidates.find(function(b){return b.chain;})||(candidates.length===1?candidates[0]:null);
+        if(!ref||ref.ts<left||ref.ts>rt)return;
+        var x=xOf(ref.ts,rt),locked=c.state==='locked',burstAt=checkpointBursts.get(c.index),burst=animate&&burstAt?Math.max(0,1-(t-burstAt)/1400):0;
+        var band=ctx.createLinearGradient(x-20,0,x+36,0);band.addColorStop(0,rgba(col.ember,0));band.addColorStop(.38,rgba(col.ember,locked?.09:.035));band.addColorStop(1,rgba(col.ember,0));ctx.fillStyle=band;ctx.fillRect(x-20,padT-12,56,plotH+12);
+        ctx.strokeStyle=rgba(col.ember,locked?.6:.32);ctx.lineWidth=locked?1.5:1;ctx.setLineDash(locked?[]:[3,6]);ctx.beginPath();ctx.moveTo(x,padT-14);ctx.lineTo(x,H-padB);ctx.stroke();ctx.setLineDash([]);
+        if(burst>0){ctx.strokeStyle=rgba(col.molten,burst*.5);ctx.lineWidth=1;ctx.strokeRect(x-(1-burst)*42,padT-12,(1-burst)*84,plotH+12);}
+        if(!compact && (narrow || W>510))cpLabels.push({x:x,cp:c,locked:locked});
+      });
+      cpLabels.sort(function(a,b){return b.x-a.x;});var cpLast=Infinity;
+      cpLabels.forEach(function(p){var pct=p.cp.fraction_total===null||p.cp.fraction_total===undefined?'':Math.round(p.cp.fraction_total*100)+'%',label=narrow?(pct||(p.locked?'LOCKED':'PENDING')):(p.locked?'LOCKED':'PENDING')+(pct?' '+pct:''),w=label.length*5.5+(narrow?14:22),x=clamp(p.x-w/2,padL,W-padR-w);if(x+w+8>cpLast)return;cpLast=x;
+        ctx.fillStyle=col.bg;ctx.strokeStyle=rgba(col.ember,p.locked?.45:.23);rounded(ctx,x,17,w,22,4);ctx.fill();ctx.stroke();ctx.font='9px ui-monospace, monospace';ctx.fillStyle=p.locked?col.ember:col.ash;ctx.textAlign='center';ctx.textBaseline='middle';ctx.fillText(label,x+w/2,28);
+      });
+      // Animate lane transitions without changing their underlying key identity.
+      blocks.forEach(function(b){b.x=xOf(b.ts,rt);var progress=animate?clamp((clock-b.laneAt)/450,0,1):1;progress=1-Math.pow(1-progress,3);b.y=b.fromY+(b.targetY-b.fromY)*progress;b.on=b.ts>=left&&b.ts<=rt&&passes(b);if(b.on&&b.newArrival&&b.visibleAt===null){b.visibleAt=t;b.born=t;}});
+      ctx.save();ctx.beginPath();ctx.rect(padL-1,padT-15,plotW+2,plotH+25);ctx.clip();
+      blocks.forEach(function(b){if(!b.on)return;var bSel=selected&&b.hash===selected;b.parents.forEach(function(hash,pi){var p=view.get(hash);if(!p||!passes(p)||p.x>W-padR||p.x<padL-plotW*.2)return;
+        var path=b.chain&&p.chain,selectedEdge=selected&&(b.hash===selected||p.hash===selected);
+        if(!path&&!selectedEdge){if(narrow||pi>0)return;var li=laneOf.has(b.miner)?laneOf.get(b.miner):lanes.length-1,lp=laneOf.has(p.miner)?laneOf.get(p.miner):lanes.length-1;if(Math.abs(li-lp)>laneReach)return;}
+        if(path||selectedEdge){ctx.strokeStyle=rgba(path?col.ember:col.bone,path?.1:.10);ctx.lineWidth=path?8:4;curve(b,p);ctx.stroke();}
+        ctx.strokeStyle=rgba(path?col.ember:selectedEdge?col.bone:b.color==='red'?col.red:col.ash,path?.68:selectedEdge?.7:hairAlpha);ctx.lineWidth=path?1.65:selectedEdge?1.4:1;curve(b,p);ctx.stroke();
+        var age=t-b.born;if(animate&&age>=0&&age<1400){var f=clamp(age/1150,0,1),pt=pointOn(b,p,f);ctx.shadowBlur=10;ctx.shadowColor=path?col.ember:col.blue;ctx.fillStyle=path?col.molten:col.blue;ctx.beginPath();ctx.arc(pt.x,pt.y,path?2.2:1.65,0,TAU);ctx.fill();ctx.shadowBlur=0;}
+      });});
+      var S=compact?6.5:narrow?clamp(lh*.24,narrowMinNode,15):clamp(lh*.22,minNode,13);
+      blocks.forEach(function(b){if(!b.on)return;
+        var age=t-b.born,newness=animate?Math.max(clamp(1-age/1700,0,1),clamp(1-(t-b.changed)/900,0,1)*.65):0;
+        var ink=b.color==='red'?col.red:b.chain?col.ember:b.color==='blue'?col.blue:col.ash;
+        var isOwn=own(b),isSelected=b.hash===selected||b.hash===hover,inOthers=!laneOf.has(b.miner),sz=S*(1+(newness*.15))*(inOthers?othersScale:1);
+        if(newness>0||isOwn||isSelected){var glow=ctx.createRadialGradient(b.x,b.y,0,b.x,b.y,sz*3.8);glow.addColorStop(0,rgba(isOwn?col.molten:ink,newness*.26+(isSelected?.15:isOwn?.06:0)));glow.addColorStop(1,rgba(ink,0));ctx.fillStyle=glow;ctx.fillRect(b.x-sz*4,b.y-sz*4,sz*8,sz*8);}
+        ctx.globalAlpha=(b.color==='red'?.78:1)*(inOthers&&!isSelected&&!isOwn?othersScale:1);
+        // a proven block glows and carries a ring, so the proof reads from across the room
+        if(provenGlow&&b.proven){var pg=ctx.createRadialGradient(b.x,b.y,0,b.x,b.y,sz*3.2);pg.addColorStop(0,rgba(ink,.26));pg.addColorStop(1,rgba(ink,0));ctx.fillStyle=pg;ctx.fillRect(b.x-sz*3.4,b.y-sz*3.4,sz*6.8,sz*6.8);ctx.strokeStyle=rgba(ink,.6);ctx.lineWidth=1;ctx.beginPath();ctx.arc(b.x,b.y,sz+5,0,TAU);ctx.stroke();}
+        // Inset tiles: inclusion is the outline; proof is the core, never the same status.
+        ctx.fillStyle=col.bg;ctx.strokeStyle=rgba(ink,b.chain?.95:.8);ctx.lineWidth=b.chain?1.75:1.25;rounded(ctx,b.x-sz,b.y-sz,2*sz,2*sz,3);ctx.fill();ctx.stroke();
+        var tile=ctx.createLinearGradient(b.x,b.y-sz,b.x,b.y+sz);tile.addColorStop(0,rgba(ink,b.proven?.5:.16));tile.addColorStop(1,rgba(ink,b.proven?.22:.025));ctx.fillStyle=tile;rounded(ctx,b.x-sz+2,b.y-sz+2,2*sz-4,2*sz-4,2);ctx.fill();
+        if(b.proven){ctx.strokeStyle=rgba(b.color==='red'?col.red:col.bone,.9);ctx.lineWidth=1.3;ctx.beginPath();ctx.moveTo(b.x-3,b.y);ctx.lineTo(b.x-1,b.y+2);ctx.lineTo(b.x+3,b.y-2);ctx.stroke();}
+        else if(b.color==='red'){ctx.strokeStyle=ink;ctx.lineWidth=1.1;ctx.beginPath();ctx.moveTo(b.x-2,b.y-2);ctx.lineTo(b.x+2,b.y+2);ctx.moveTo(b.x+2,b.y-2);ctx.lineTo(b.x-2,b.y+2);ctx.stroke();}
+        else{ctx.fillStyle=rgba(ink,.65);ctx.fillRect(b.x-1.3,b.y-1.3,2.6,2.6);}
+        if(!compact && b.shards.length){var total=b.shards.length,shown=Math.min(total,8),gap=1.6,barW=2*sz,seg=(barW-gap*(shown-1))/shown;
+          for(var k=0;k<shown;k++){var shard=b.shards[k].state,alpha=shard==='proving'?(animate?.5+.4*Math.sin(t/300+k):.8):1;
+            ctx.fillStyle=rgba(shard==='paid'?col.molten:shard==='verified'?col.bone:shard==='proving'?col.ember:col.line2,alpha);ctx.fillRect(b.x-sz+k*(seg+gap),b.y+sz+4,Math.max(1,seg),2);
+          }
+        }
+        if(isOwn){ctx.strokeStyle=col.molten;ctx.lineWidth=1.2;var q=sz+4;ctx.beginPath();[[1,1],[1,-1],[-1,1],[-1,-1]].forEach(function(v){ctx.moveTo(b.x+v[0]*(q-4),b.y+v[1]*q);ctx.lineTo(b.x+v[0]*q,b.y+v[1]*q);ctx.lineTo(b.x+v[0]*q,b.y+v[1]*(q-4));});ctx.stroke();}
+        if(b.locked){ctx.strokeStyle=rgba(col.ember,.6);ctx.lineWidth=1;ctx.beginPath();ctx.arc(b.x,b.y,sz+8,0,TAU);ctx.stroke();}
+        if(b.final){ctx.fillStyle=rgba(col.ember,.75);ctx.beginPath();ctx.arc(b.x+sz-1,b.y-sz-2,2,0,TAU);ctx.fill();}
+        if(isSelected){ctx.strokeStyle=col.bone;ctx.lineWidth=1;ctx.setLineDash([3,3]);rounded(ctx,b.x-sz-8,b.y-sz-8,2*sz+16,2*sz+16,6);ctx.stroke();ctx.setLineDash([]);}
+        ctx.globalAlpha=1;
+      });ctx.restore();
+      // Timeline and feed edge. No fabricated DAA ticks or estimated checkpoint positions.
+      ctx.font=(compact?'8':'9')+'px ui-monospace, monospace';ctx.fillStyle=col.ash;ctx.textBaseline='middle';
+      var ticks=W<420?2:4;
+      for(var q=0;q<=ticks;q++){var tx=padL+plotW*q/ticks;ctx.textAlign=q===0?'left':q===ticks?'right':'center';var label=q===ticks?(paused?'PAUSED':!following?'HISTORY':state==='live'?'OBSERVED NOW':state.toUpperCase()):'-'+Math.round(windowS*(1-q/ticks))+'s';ctx.fillText(label,tx,H-(compact?8:13));}
+      if(!compact){var visibleBlocks=blocks.filter(function(b){return b.on;});ctx.font='8px ui-monospace, monospace';ctx.textAlign='left';ctx.fillStyle=rgba(col.ash,.8);if(padL>50)ctx.fillText('HEADER TIME',12,H-13);
+        if(visibleBlocks.length && W>600){var last=visibleBlocks[visibleBlocks.length-1];ctx.textAlign='right';ctx.fillText('DAA '+fmt(last.daa),W-padR,8);}
+      }
+      if(state==='live'&&following&&!paused){ctx.strokeStyle=rgba(col.ember,.3);ctx.beginPath();ctx.moveTo(W-padR,padT-9);ctx.lineTo(W-padR,H-padB);ctx.stroke();ctx.fillStyle=col.ember;ctx.beginPath();ctx.arc(W-padR,padT-12,2.3,0,TAU);ctx.fill();}
+      if(!blocks.some(function(b){return b.on;})){
+        ctx.textAlign='center';ctx.fillStyle=col.ash;ctx.font='12px system-ui, sans-serif';ctx.fillText(state==='connecting'?'Waiting for observer data':filter==='mine'?'No blocks for your key in this window':filter==='chain'?'No selected-chain blocks in this window':'No blocks in this time window',padL+plotW/2,H/2);
+      }
+      var active=selected?view.get(selected):hover?view.get(hover):null;if(active&&active.on)showTip(active);else if(tip)tip.hidden=true;
+      lastT=t;
+    }
+    function continuous(){return !destroyed&&!doc.hidden&&visible&&!paused&&!reduced&&manualMotion&&state==='live'&&blocks.length>0;}
+    function frame(t){raf=0;if(destroyed||doc.hidden||!visible)return;if(t-lastPaint>=minFrame-.5){draw(t);lastPaint=t;}if(continuous())raf=requestAnimationFrame(frame);}
+    function redraw(){if(destroyed||raf||doc.hidden||!visible)return;lastPaint=-Infinity;raf=requestAnimationFrame(frame);}
+    function stopFrame(){if(raf)cancelAnimationFrame(raf);raf=0;}
+    function words(b){
+      if(!b)return {title:'No block selected',lines:[]};
+      var inclusion=b.color==='blue'?'included':b.color==='red'?'excluded':'pending';
+      var bits=[inclusion];if(b.chain)bits.push('selected chain');if(b.proven)bits.push('proven');if(b.locked)bits.push('locked checkpoint');if(b.final)bits.push('final');
+      return {title:b.hash+'  '+bits.join(' / '),lines:[(own(b)?'Your block / ':'')+'miner key '+b.miner,
+        'Blue score '+fmt(b.blue_score===undefined?b.blue:b.blue_score)+' / DAA '+fmt(b.daa),b.parents.length+' parent'+(b.parents.length===1?'':'s'),
+        'Shards: '+(b.shards.length?b.shards.map(function(s){return s.state;}).join(', '):'no shard plan yet')]};
+    }
+    function showTip(b){
+      if(!tip)return;
+      if(!b){tip.hidden=true;return;}
+      var w=words(b),key=w.title+'|'+w.lines.join('|');
+      if(tip.dataset.igneumKey!==key){tip.replaceChildren();var title=doc.createElement('b');title.textContent=w.title;tip.appendChild(title);w.lines.forEach(function(line){var p=doc.createElement('span');p.textContent=line;p.style.display='block';tip.appendChild(p);});tip.dataset.igneumKey=key;}
+      tip.hidden=false;tip.style.pointerEvents='none';tip.style.position='absolute';tip.style.left='0px';tip.style.top='0px';tip.style.maxWidth=Math.max(160,W-24)+'px';tip.style.whiteSpace='normal';tip.style.overflowWrap='anywhere';
+      var host=tip.offsetParent||canvas.parentElement,cr=canvas.getBoundingClientRect(),pr=host.getBoundingClientRect();
+      var tw=tip.offsetWidth,th=tip.offsetHeight;var x=clamp(b.x+16,8,Math.max(8,W-tw-8)),y=b.y-th-18;if(y<8)y=Math.min(H-th-8,b.y+22);
+      tip.style.transform='translate('+Math.round(cr.left-pr.left-host.clientLeft+x)+'px,'+Math.round(cr.top-pr.top-host.clientTop+Math.max(8,y))+'px)';
+    }
+    function hit(ev){var p=eventXY(ev),best=null,dist=22*22;blocks.forEach(function(b){if(!b.on)return;var d=(b.x-p.x)**2+(b.y-p.y)**2;if(d<dist){dist=d;best=b;}});return best;}
+    function select(hash,why){if(hash!==null&&!view.has(hash))return false;selected=hash;showTip(hash?view.get(hash):null);emit('onSelect',hash?cloneBlock(view.get(hash)):null,why||'select');redraw();return true;}
+    function engage(onValue){var value=!!onValue;if(engaged===value)return;engaged=value;canvas.classList.toggle('engaged',value);if(chip)chip.hidden=!value;emit('onEngage',value);}
+    function setWindow(seconds){var n=Math.round(clamp(seconds,30,300));if(!finite(n)||n===windowS)return;windowTouched=true;windowS=n;layout();emit('onWindow',n);emit('onStats',stats());poll();redraw();}
+    function zoom(f){if(!finite(f)||f<=0)return;setWindow(windowS*f);}
+    function follow(){following=true;fixedRight=0;if(paused)pausedRight=Date.now()-lag;layout();emit('onFollow',true);redraw();}
+    function setPaused(p){p=!!p;if(paused===p)return;
+      if(p){pausedRight=rightTime();freezeT=performance.now();paused=true;stopFrame();}
+      else{paused=false;syncView();}
+      if(opts.pauseButton){opts.pauseButton.setAttribute('aria-pressed',String(paused));opts.pauseButton.textContent=paused?'Resume':'Pause';}
+      emit('onPause',paused);emit('onStats',stats());redraw();
+    }
+    function setFilter(value){if(!['all','chain','mine'].includes(value))return;filter=value;select(null,'filter');layout();redraw();}
+    function setMotion(value){manualMotion=!!value;reducedRight=Date.now()-lag;stopFrame();redraw();}
+    function panTo(right){following=false;fixedRight=Math.min(right,Date.now()-lag);if(paused)pausedRight=fixedRight;emit('onFollow',false);layout();redraw();}
+    canvas.setAttribute('tabindex',canvas.getAttribute('tabindex')||'0');canvas.setAttribute('role','img');
+    if(!canvas.getAttribute('aria-label'))canvas.setAttribute('aria-label','Interactive block graph. Arrow keys inspect blocks. Plus and minus zoom. Space pauses, F follows, Escape releases.');
+    canvas.style.touchAction='pan-y';
+    on(canvas,'pointerdown',function(ev){if(ev.pointerType==='touch'||ev.button!==0)return;canvas.focus({preventScroll:true});engage(true);drag={id:ev.pointerId,x:ev.clientX,start:rightTime(),moved:false};canvas.setPointerCapture(ev.pointerId);});
+    on(canvas,'pointermove',function(ev){
+      if(drag&&drag.id===ev.pointerId){var dx=ev.clientX-drag.x;if(Math.abs(dx)>4)drag.moved=true;if(drag.moved){panTo(drag.start-dx*windowS*1000/Math.max(1,W-padL-padR));canvas.style.cursor='grabbing';return;}}
+      var b=hit(ev);hover=b?b.hash:null;canvas.style.cursor=b?'pointer':'grab';if(!selected)showTip(b);if(!continuous())redraw();
+    });
+    on(canvas,'pointerup',function(ev){if(ev.pointerType==='touch')return;if(!drag||drag.id!==ev.pointerId)return;var moved=drag.moved;drag=null;if(canvas.hasPointerCapture(ev.pointerId))canvas.releasePointerCapture(ev.pointerId);canvas.style.cursor='grab';if(!moved){var b=hit(ev);select(b&&selected!==b.hash?b.hash:null,'pointer');}});
+    on(canvas,'pointercancel',function(){drag=null;});
+    on(canvas,'pointerleave',function(){hover=null;if(!drag)engage(false);if(!selected)showTip(null);redraw();});
+    on(canvas,'wheel',function(ev){if(!ev.ctrlKey&&!ev.metaKey&&!engaged)return;if(Math.abs(ev.deltaY)<1)return;ev.preventDefault();zoom(ev.deltaY>0?1.15:1/1.15);},{passive:false});
+    var touchStart=null;
+    function dist(touches){return Math.hypot(touches[0].clientX-touches[1].clientX,touches[0].clientY-touches[1].clientY);}
+    on(canvas,'touchstart',function(ev){if(ev.touches.length===2){pinch={distance:dist(ev.touches),window:windowS};touchStart=null;}else if(ev.touches.length===1){touchStart={x:ev.touches[0].clientX,y:ev.touches[0].clientY};}},{passive:true});
+    on(canvas,'touchmove',function(ev){if(ev.touches.length===2&&pinch){ev.preventDefault();setWindow(pinch.window*pinch.distance/Math.max(1,dist(ev.touches)));}else if(touchStart&&ev.touches.length){if(Math.hypot(ev.touches[0].clientX-touchStart.x,ev.touches[0].clientY-touchStart.y)>8)touchStart=null;}},{passive:false});
+    on(canvas,'touchend',function(ev){if(pinch){if(ev.touches.length<2)pinch=null;touchStart=null;return;}if(touchStart&&ev.changedTouches.length){var b=hit(ev.changedTouches[0]);select(b&&selected!==b.hash?b.hash:null,'touch');touchStart=null;}},{passive:true});
+    on(canvas,'keydown',function(ev){
+      var key=ev.key;if(['ArrowLeft','ArrowRight','ArrowUp','ArrowDown','Home','End'].includes(key)){
+        ev.preventDefault();var list=blocks.filter(function(b){return b.on;}),i=list.findIndex(function(b){return b.hash===selected;}),next;
+        if(!list.length)return;if(key==='Home')next=0;else if(key==='End')next=list.length-1;else next=i<0?list.length-1:clamp(i+(['ArrowRight','ArrowDown'].includes(key)?1:-1),0,list.length-1);select(list[next].hash,'keyboard');
+      }else if(key===' '){ev.preventDefault();setPaused(!paused);}else if(key==='+'||key==='='){ev.preventDefault();zoom(1/1.2);}else if(key==='-'){ev.preventDefault();zoom(1.2);}else if(key.toLowerCase()==='f'){ev.preventDefault();follow();}
+    });
+    on(doc,'keydown',function(ev){if(ev.key==='Escape'&&(engaged||doc.activeElement===canvas)){engage(false);select(null,'escape');}});
+    on(doc,'pointerdown',function(ev){if(engaged&&ev.target!==canvas&&!(chip&&chip.contains(ev.target)))engage(false);});
+    if(opts.pauseButton){opts.pauseButton.setAttribute('aria-pressed','false');on(opts.pauseButton,'click',function(){setPaused(!paused);});}
+    on(root,'resize',size);
+    if('ResizeObserver'in root){ro=new ResizeObserver(size);ro.observe(canvas);}
+    if('IntersectionObserver'in root){io=new IntersectionObserver(function(es){visible=es[0].isIntersecting;if(visible)redraw();else stopFrame();},{threshold:0});io.observe(canvas);}
+    if('MutationObserver'in root){mo=new MutationObserver(theme);mo.observe(doc.documentElement,{attributes:true,attributeFilter:['data-theme','class','style']});}
+    if(mq&&mq.addEventListener)on(mq,'change',function(e){reduced=e.matches;reducedRight=Date.now()-lag;stopFrame();redraw();});
+    if(mediaTheme&&mediaTheme.addEventListener)on(mediaTheme,'change',theme);
+    on(doc,'visibilitychange',function(){if(doc.hidden){stopFrame();clearTimeout(pollTimer);if(controller)controller.abort();}else{poll();redraw();}});
+    healthTimer=setInterval(function(){if(destroyed||doc.hidden||!lastGood)return;if(state==='live'&&Date.now()-lastGood>(finite(opts.staleAfterMs)?opts.staleAfterMs:15000))setState('stale','No observer update for '+Math.round((Date.now()-lastGood)/1000)+' s');},1000);
+    function destroy(){if(destroyed)return;destroyed=true;stopFrame();clearTimeout(pollTimer);clearTimeout(timeout);clearInterval(healthTimer);if(controller)controller.abort();remove.forEach(function(fn){fn();});if(ro)ro.disconnect();if(io)io.disconnect();if(mo)mo.disconnect();if(tip)tip.hidden=true;canvas.classList.remove('engaged');
+      [['tabindex',initialAttributes.tabindex],['role',initialAttributes.role],['aria-label',initialAttributes.label]].forEach(function(pair){if(pair[1]===null)canvas.removeAttribute(pair[0]);else canvas.setAttribute(pair[0],pair[1]);});canvas.style.touchAction=initialAttributes.touch;canvas.style.cursor=initialAttributes.cursor;instances.delete(canvas);model.clear();view.clear();blocks=[];
+    }
+    var api={push:push,setPaused:setPaused,zoom:zoom,engage:engage,getWindow:function(){return windowS;},getState:function(){return {state:state,reason:reason};},redraw:redraw,words:words,
+      destroy:destroy,follow:follow,setWindow:setWindow,setFilter:setFilter,setMotion:setMotion,select:select,getStats:stats,
+      getViewRange:function(){return {start:rightTime()-windowS*1000,end:rightTime(),filter:filter};},getBlocks:function(){return blocks.map(cloneBlock);},getCheckpoints:function(){return cps.map(function(c){return Object.assign({},c);});},
+      getSnapshot:function(){return {ok:true,state:{stale:state!=='live'},blocks:blocks.map(cloneBlock),finality:{checkpoints:cps.map(function(c){return Object.assign({},c);})}};}};
+    instances.set(canvas,api);if(chip)chip.hidden=true;theme();size();emit('onState',state,reason);if(opts.poll!==false)poll();redraw();return api;
+  }
+  root.IgneumDag={mount:mount,version:'2.0.2'};
+})(window);

app/igneum-app/ui/notices.test.mjs

@@ -96,7 +96,7 @@ test('update wording: available, downloading with percent, installing, failed wi
   assert.equal(updateNotice(upd({ status: 'deferred' }), s()).text, 'Igneum Miner 0.3.6 is waiting for permission. It installs the next time someone is at this PC. Mining continues.');
   // updated: gone within 60 s of the new version starting
   const cur = upd({ status: 'current', available: false, ready: false, downloaded: false, updated_from: '0.3.4' });
-  assert.equal(updateNotice(cur, s({ version: '0.3.6', uptime_s: 59 })).text, 'Updated to Igneum Miner 0.3.6 from 0.3.4.');
+  assert.match(updateNotice(cur, s({ version: '0.3.6', uptime_s: 59, now: 1_800_000_000 })).text, /^Updated to 0\.3\.6 at \d\d:\d\d\.$/);
   assert.equal(updateNotice(cur, s({ version: '0.3.6', uptime_s: 60 })), null);
   assert.equal(updateNotice(upd({ status: 'current', available: false }), s()), null);
   // a build with no manifest reports an error the user cannot act on: no notice (the Settings note still says it)
@@ -106,22 +106,26 @@ test('update wording: available, downloading with percent, installing, failed wi
 
 test('job wording: running with minutes and stage, done goes after 5 minutes, failed stays with the first error line', () => {
   const r = jobNotice(run(), NOW);
-  assert.equal(r.text, 'Job: shard benchmark running, 6 min. Proving shard 3 of 8.');
-  assert.equal(r.detail, 'RESULT shard=2 prove_s=39.8');
-  assert.equal(jobNotice(run({ stage: '' }), NOW).text, 'Job: shard benchmark running, 6 min.');
+  assert.equal(r.text, 'A job from the team is running: shard benchmark, 6 min. Proving shard 3 of 8.');
+  assert.equal(r.detail, 'shard benchmark · RESULT shard=2 prove_s=39.8', 'the technical line goes behind the chevron');
+  assert.equal(jobNotice(run({ stage: '' }), NOW).text, 'A job from the team is running: shard benchmark, 6 min.');
   const d = jobNotice(fin('done'), NOW);
-  assert.equal(d.text, 'Job: build done after 32 min. Report uploaded.');
+  assert.equal(d.text, 'A job from the team ran: build, 32 min.');
   assert.equal(d.key, 'job:done:job-6');
   assert.ok(jobNotice(fin('done'), NOW - 60 + N.JOB_DONE_S));
   assert.equal(jobNotice(fin('done'), NOW - 60 + N.JOB_DONE_S + 1), null);
   const f = jobNotice(fin('failed'), NOW);
-  assert.equal(f.text, 'Job: build failed after 32 min, exit 1. Report not uploaded.');
-  assert.equal(f.detail, 'BUILD FAILED: error[E0425]: cannot find value `foo`');
+  assert.equal(f.text, 'A job from the team failed: build, after 32 min. The report did not upload.');
+  assert.match(f.detail, /BUILD FAILED: error\[E0425\]: cannot find value `foo` · exit 1$/);
   assert.equal(f.tone, 'bad');
   assert.ok(jobNotice(fin('failed'), NOW + 86400 * 7), 'a failed job stays until closed');
   // no error line among the results: the summary is the cause
-  assert.equal(jobNotice(fin('failed', { last_results: ['STAGE build'] }), NOW).detail, 'build exited with code 1');
-  assert.equal(jobNotice(fin('timeout'), NOW).text, 'Job: build hit its time cap after 32 min, exit 1. Report not uploaded.');
+  assert.match(jobNotice(fin('failed', { last_results: ['STAGE build'] }), NOW).detail, /^build: build exited with code 1 · exit 1$/);
+  assert.equal(jobNotice(fin('timeout'), NOW).text, 'A job from the team ran out of time: build, after 32 min. The report did not upload.');
+  assert.equal(N.jobWord('', 'update-now-0313-switch-d937c69d'), 'update check');
+  assert.equal(N.jobWord('restart', 'restart-miners-0312'), 'restart');
+  assert.equal(N.jobWord('collect', ''), 'log collection');
+  assert.equal(N.jobWord('', 'ember-tune-pc1-5'), 'tuning check');
   assert.equal(jobNotice({ active: false, last: {} }, NOW), null);
   assert.equal(jobNotice(null, NOW), null);
 });

app/igneum-app/ui/proof-core.js

@@ -0,0 +1,72 @@
+/* Igneum proof detail. A data-driven companion, not a mining-progress estimate.
+ * One orbital tile per displayed shard (up to 12). No time-based status promotion.
+ * IgneumProof.mount(canvas).setBlock(observerBlock); destroy() on unmount.
+ */
+(function(root){
+'use strict';
+var mounted=new WeakMap(),TAU=Math.PI*2;
+function mount(canvas,opts){
+  opts=opts||{};if(mounted.has(canvas))mounted.get(canvas).destroy();
+  var ctx=canvas.getContext('2d');if(!ctx)throw new Error('A 2D canvas context is required.');
+  var W=0,H=0,dpr=1,block=null,raf=0,disposed=false,paused=false,inView=true,lastPaint=0,frames=0,force=true;
+  var mq=matchMedia('(prefers-reduced-motion: reduce)'),reduce=mq.matches,motion=true,col={},ro,io,mo;
+  var phase=0,lastT=0;
+  function alpha(c,a){if(/^#[a-f\d]{6}$/i.test(c))return 'rgba('+parseInt(c.slice(1,3),16)+','+parseInt(c.slice(3,5),16)+','+parseInt(c.slice(5,7),16)+','+a+')';return c;}
+  function theme(){var s=getComputedStyle(document.documentElement);function c(k,f){return s.getPropertyValue(k).trim()||f;}col={ember:c('--ember','#F2541B'),gold:c('--molten','#FFB35C'),bone:c('--bone','#F4F1EC'),ash:c('--ash','#9A9A9E'),line:c('--line','#2A2A30'),surface:c('--graphite','#16161A'),bg:c('--row','#111114')};kick();}
+  function size(){var nw=canvas.clientWidth,nh=canvas.clientHeight,nd=Math.min(devicePixelRatio||1,2);if(W===nw&&H===nh&&dpr===nd&&canvas.width===Math.round(nw*nd)){kick();return;}W=nw;H=nh;dpr=nd;canvas.width=W*dpr;canvas.height=H*dpr;ctx.setTransform(dpr,0,0,dpr,0,0);kick();}
+  function poly(points,fill,stroke){ctx.beginPath();points.forEach(function(p,i){if(i===0)ctx.moveTo(p[0],p[1]);else ctx.lineTo(p[0],p[1]);});ctx.closePath();if(fill){ctx.fillStyle=fill;ctx.fill();}if(stroke){ctx.strokeStyle=stroke;ctx.stroke();}}
+  function iso(x,y,w,h,depth,fill,stroke){
+    poly([[x-w,y],[x,y+h],[x,y+h+depth],[x-w,y+depth]],alpha(fill,.17),alpha(stroke,.4));
+    poly([[x,y+h],[x+w,y],[x+w,y+depth],[x,y+h+depth]],alpha(fill,.07),alpha(stroke,.32));
+    poly([[x,y-h],[x+w,y],[x,y+h],[x-w,y]],col.bg,stroke);
+    poly([[x,y-h],[x+w,y],[x,y+h],[x-w,y]],alpha(fill,.15),null);
+  }
+  function line(a,b,c,w){ctx.strokeStyle=c;ctx.lineWidth=w||1;ctx.beginPath();ctx.moveTo(a[0],a[1]);ctx.lineTo(b[0],b[1]);ctx.stroke();}
+  function draw(t){
+    if(!W||!H||disposed)return;frames++;
+    if(lastT&&!reduce&&motion&&!paused)phase+=Math.min(t-lastT,70)/1000;lastT=t;
+    ctx.setTransform(dpr,0,0,dpr,0,0);ctx.clearRect(0,0,W,H);
+    var x=W*.5,y=H*.49,scale=Math.min(W/320,H/240),cw=43*scale,ch=23*scale;
+    var shards=block?block.shards||[]:[],active=shards.some(function(s){return s.state==='proving';});
+    var glow=ctx.createRadialGradient(x,y,0,x,y,W*.43);glow.addColorStop(0,alpha(col.ember,.10));glow.addColorStop(1,alpha(col.ember,0));ctx.fillStyle=glow;ctx.fillRect(0,0,W,H);
+    // A stationary coordinate grid, not fabricated hashrate or work counters.
+    for(var k=-3;k<=3;k++){line([x-130*scale,y+k*18*scale-46*scale],[x+130*scale,y+k*18*scale+46*scale],alpha(col.line,.45));line([x-130*scale,y+k*18*scale+46*scale],[x+130*scale,y+k*18*scale-46*scale],alpha(col.line,.45));}
+    ctx.strokeStyle=alpha(col.line,.7);ctx.lineWidth=1;ctx.setLineDash([2,6]);ctx.beginPath();ctx.ellipse(x,y+10*scale,106*scale,59*scale,0,0,TAU);ctx.stroke();ctx.setLineDash([]);
+    var count=Math.min(12,shards.length);
+    for(var i=0;i<count;i++){
+      var angle=-Math.PI/2+i/count*TAU,px=x+Math.cos(angle)*108*scale,py=y+Math.sin(angle)*57*scale;
+      var state=shards[i].state,ink=state==='proving'?col.ember:state==='paid'?col.gold:state==='verified'?col.bone:col.ash;
+      var midx=(px+x)/2,midy=(py+y)/2;
+      ctx.strokeStyle=alpha(ink,state==='planned'?.14:.38);ctx.lineWidth=1;ctx.beginPath();ctx.moveTo(px,py);ctx.quadraticCurveTo(midx,midy-12*scale,x,y);ctx.stroke();
+      if(state==='proving'&&!reduce&&motion&&!paused){var p=(phase*.48+i*.33)%1,xx=(1-p)*(1-p)*px+2*(1-p)*p*midx+p*p*x,yy=(1-p)*(1-p)*py+2*(1-p)*p*(midy-12*scale)+p*p*y;ctx.fillStyle=col.gold;ctx.shadowBlur=8;ctx.shadowColor=col.ember;ctx.beginPath();ctx.arc(xx,yy,1.8*scale,0,TAU);ctx.fill();ctx.shadowBlur=0;}
+      iso(px,py,13*scale,7*scale,5*scale,ink,alpha(ink,.72));
+      if(state==='verified'||state==='paid'){ctx.strokeStyle=ink;ctx.lineWidth=1.2;ctx.beginPath();ctx.moveTo(px-4*scale,py);ctx.lineTo(px-1*scale,py+2*scale);ctx.lineTo(px+4*scale,py-2*scale);ctx.stroke();}
+      else{ctx.fillStyle=alpha(ink,state==='proving'?.9:.4);ctx.fillRect(px-1.5*scale,py-1.5*scale,3*scale,3*scale);}
+      ctx.font='8px ui-monospace, monospace';ctx.textAlign='center';ctx.fillStyle=col.ash;ctx.fillText('S'+String(i+1).padStart(2,'0'),px,py+22*scale);
+    }
+    // Layered block core. Geometry does not imply three GPUs or three proofs.
+    var lift=active&&!reduce&&motion&&!paused?Math.sin(phase*1.7)*1.8*scale:0;
+    ctx.lineWidth=1;
+    iso(x,y+21*scale,cw,ch,10*scale,col.ember,alpha(col.ember,.34));
+    iso(x,y+6*scale,cw,ch,8*scale,col.ember,alpha(col.ember,.55));
+    iso(x,y-11*scale-lift,cw,ch,7*scale,col.ember,alpha(col.ember,.85));
+    var topY=y-11*scale-lift;
+    poly([[x,topY-13*scale],[x+25*scale,topY],[x,topY+13*scale],[x-25*scale,topY]],alpha(col.ember,block&&block.proven?.28:.06),alpha(col.gold,.46));
+    if(block&&block.proven){ctx.strokeStyle=col.gold;ctx.lineWidth=1.8;ctx.beginPath();ctx.moveTo(x-7*scale,topY);ctx.lineTo(x-2*scale,topY+4*scale);ctx.lineTo(x+8*scale,topY-4*scale);ctx.stroke();}
+    else{ctx.fillStyle=col.ember;ctx.fillRect(x-2*scale,topY-2*scale,4*scale,4*scale);}
+    if(block&&block.locked){ctx.strokeStyle=col.gold;ctx.lineWidth=1.2;ctx.beginPath();ctx.ellipse(x,y+12*scale,67*scale,38*scale,0,0,TAU);ctx.stroke();ctx.font='8px ui-monospace, monospace';ctx.fillStyle=col.gold;ctx.textAlign='center';ctx.fillText('LOCKED CHECKPOINT',x,H-12);}
+    else if(!block){ctx.font='10px ui-monospace, monospace';ctx.textAlign='center';ctx.fillStyle=col.ash;ctx.fillText('SELECT A BLOCK',x,H-12);}
+    else if(shards.length>12){ctx.font='9px ui-monospace, monospace';ctx.textAlign='center';ctx.fillStyle=col.ash;ctx.fillText('+ '+(shards.length-12)+' more shards in the list',x,H-12);}
+  }
+  function continuous(){return !disposed&&!document.hidden&&inView&&!reduce&&motion&&!paused&&block&&(block.shards||[]).some(function(s){return s.state==='proving';});}
+  function frame(t){raf=0;if(disposed||document.hidden||!inView)return;if(force||t-lastPaint>=1000/30){draw(t);lastPaint=t;force=false;}if(continuous())raf=requestAnimationFrame(frame);}
+  function kick(){force=true;if(!disposed&&!document.hidden&&inView&&!raf)raf=requestAnimationFrame(frame);}
+  function stop(){if(raf)cancelAnimationFrame(raf);raf=0;lastT=0;}
+  function visibility(){if(document.hidden)stop();else kick();}
+  function reduction(e){reduce=e.matches;stop();kick();}
+  var api={setBlock:function(b){block=b?{hash:b.hash,proven:b.proven===true,locked:b.locked===true,shards:(b.shards||[]).map(function(s){return {state:s.state};})}:null;canvas.setAttribute('aria-label',block?'Block proof detail: '+block.shards.map(function(s,i){return 'shard '+(i+1)+' '+s.state;}).join(', '):'Select a block to inspect its proof shards');kick();},setPaused:function(value){paused=!!value;stop();kick();},setMotion:function(value){motion=!!value;stop();kick();},getStats:function(){return {frames:frames,reducedMotion:reduce||!motion};},destroy:function(){if(disposed)return;disposed=true;stop();ro.disconnect();if(io)io.disconnect();mo.disconnect();root.removeEventListener('resize',size);document.removeEventListener('visibilitychange',visibility);mq.removeEventListener('change',reduction);mounted.delete(canvas);}};
+  ro=new ResizeObserver(size);ro.observe(canvas);if('IntersectionObserver'in root){io=new IntersectionObserver(function(es){inView=es[0].isIntersecting;if(inView)kick();else stop();});io.observe(canvas);}mo=new MutationObserver(theme);mo.observe(document.documentElement,{attributes:true,attributeFilter:['data-theme','style','class']});
+  root.addEventListener('resize',size);document.addEventListener('visibilitychange',visibility);mq.addEventListener('change',reduction);mounted.set(canvas,api);theme();size();return api;
+}
+root.IgneumProof={mount:mount,version:'2.0.0'};
+})(window);

app/igneum-app/ui/ui-ota.test.mjs

@@ -0,0 +1,49 @@
+// node --test app/igneum-app/ui/ui-ota.test.mjs   (no dependencies; the pre-push gate runs it)
+// The interface over the air (docs/plans/ui-ota.md): Settings > Interface's words and the gentle reload rule.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const src = readFileSync(join(here, 'app.js'), 'utf8');
+const mod = { exports: {} };
+new Function('module', src)(mod);
+const V = mod.exports.View;
+
+test('the embedded interface says built in; an over-the-air one says so with its date', () => {
+  assert.deepEqual(V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.0', source: 'embedded', confirmed: true }), { line: 'Interface 1.0.0, built in', eyebrow: 'built in', help: '' });
+  const w = V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.1', source: 'ota', installed_at: Date.UTC(2026, 9, 7, 12) / 1000, confirmed: true });
+  assert.equal(w.line, 'Interface 1.0.1, over the air, 7 Oct 2026');
+  assert.equal(w.eyebrow, 'over the air');
+  assert.equal(w.help, 'Built in: 1.0.0.');
+  assert.equal(V.interfaceWords({}).line, '');
+  assert.equal(readFileSync(join(here, 'VERSION'), 'utf8').trim(), '1.0.0', 'the embedded interface version is three-part and in ui/VERSION');
+});
+
+test('the help line says what is pending, refused, held back by the switch, or skipped', () => {
+  assert.equal(V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.1', source: 'ota', confirmed: false }).help, 'Waiting for this window to confirm the new interface.');
+  assert.ok(V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.0', source: 'embedded', confirmed: true, error: 'the page did not answer within 10 s of loading it.' }).help.startsWith('The last interface over the air was refused:'));
+  assert.equal(V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.0', source: 'embedded', confirmed: true, builtin: true, published_version: '1.0.2' }).help, 'Interface 1.0.2 is published over the air; switch this off to take it.');
+  assert.equal(V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.0', source: 'embedded', confirmed: true, busy: true, published_version: '1.0.2' }).help, 'Interface 1.0.2 is downloading.');
+  assert.equal(V.interfaceWords({ embedded_version: '1.0.0', active_version: '1.0.0', source: 'embedded', confirmed: true, note: 'interface 1.0.2 needs engine 0.3.20 or newer (this is 0.3.19)' }).help, 'Interface 1.0.2 needs engine 0.3.20 or newer (this is 0.3.19).');
+});
+
+test('the page reloads only when the served interface changed and nobody is mid-task', () => {
+  const u = { active_version: '1.0.1' };
+  assert.equal(V.shouldReload('1.0.0', u, { phase: 'dashboard' }), true);
+  assert.equal(V.shouldReload('1.0.1', u, { phase: 'dashboard' }), false, 'same version: nothing');
+  assert.equal(V.shouldReload('', u, { phase: 'dashboard' }), false, 'a page that never pinged does not reload');
+  assert.equal(V.shouldReload('1.0.0', u, { phase: 'dashboard', typing: true }), false);
+  assert.equal(V.shouldReload('1.0.0', u, { phase: 'dashboard', sheetOpen: true }), false);
+  assert.equal(V.shouldReload('1.0.0', u, { phase: 'address' }), false, 'never mid-setup');
+  assert.equal(V.shouldReload('1.0.0', null, { phase: 'dashboard' }), false);
+});
+
+test('the page pings health once after its first paint and reports a first-paint error (the DOM block carries both)', () => {
+  assert.ok(src.includes("api('api/ui/health', {})"), 'the health ping');
+  assert.ok(src.includes("api('api/ui/health', { error: uiFirstError })"), 'the first-paint error');
+  assert.ok(src.indexOf("window.addEventListener('error'") < src.indexOf('function poll()'), 'the error listener is installed before the first poll');
+  assert.ok(!/<script[^>]+src=["']https?:/.test(readFileSync(join(here, 'index.html'), 'utf8')), 'no remote script in the page');
+});

app/igneum-app/ui/view.test.mjs

@@ -14,10 +14,11 @@ const V = mod.exports.View;
 
 const card = (over) => ({ key: 'nvidia:0:RTX 5090', name: 'NVIDIA GeForce RTX 5090', vendor: 'nvidia', kind: 'discrete', worker: 'CUDA', vram_mb: 32768, enabled: true, state: 'mining', hash_now: 124.3, hash_avg: 120, accepted: 3, rejected: 0, identities: 8, ids: [], prepared: true, restart_in_s: 0, message: '', reason: '', power_w: 410.2, power_limit_w: 460, power_default_w: 575, power_pct: 80, power_applied: true, temp_gpu: 61, temp_mem: 72, telemetry_at: 1, ...over });
 
-test('the four sections and their order (miner-ui-3)', () => {
-  assert.deepEqual(V.PAGES.map((p) => p.id), ['mine', 'earnings', 'prove', 'settings']);
+test('the five sections and their order (miner-ui-4)', () => {
+  assert.deepEqual(V.PAGES.map((p) => p.id), ['overview', 'cards', 'earnings', 'prove', 'settings']);
+  assert.equal(V.page('cards').title, 'Cards');
   assert.equal(V.page('earnings').title, 'Earnings');
-  assert.equal(V.page('nonsense').id, 'mine');
+  assert.equal(V.page('nonsense').id, 'overview');
 });
 
 test('a GPU row: name, kind, the numbers where known, the switch', () => {
@@ -72,8 +73,8 @@ test('the big button: start when paused, stop when mining, disabled with no card
   const none = V.toggle(m({ cards: [card({ enabled: false })] }), { synced: true }, {});
   assert.equal(none.disabled, true);
   assert.equal(none.act, '');
-  assert.equal(none.sub, 'switch a GPU on below first');
-  assert.equal(V.toggle(m({ cards: [] }), { synced: true }, {}).sub, 'no GPU this app can drive');
+  assert.equal(none.sub, 'switch a card on in Cards first');
+  assert.equal(V.toggle(m({ cards: [] }), { synced: true }, {}).sub, 'no card this app can use');
   assert.equal(V.toggle(m({ state: 'waiting' }), { synced: false }, {}).sub, 'waiting for the node to sync');
   assert.equal(V.toggle(m(), { synced: true }, { quitting: true }).disabled, true);
 });
@@ -106,11 +107,11 @@ test('the next consensus switch is the first height above the DAA score, in plai
   const next = V.nextSwitch(sw, 140000);
   assert.equal(next.name, 'Fees v1');
   assert.equal(next.away, 70000);
-  assert.equal(V.switchLine(next, 140000), 'Fees v1 at DAA 210,000: 70,000 blocks away, about 19 h 27 min at one block a second.');
+  assert.equal(V.switchLine(next, 140000), 'Fees v1 at block 210,000: 70,000 blocks away, about 19 h 27 min at one block a second.');
   assert.equal(V.nextSwitch(sw, 20000).name, 'Difficulty v2');
   assert.equal(V.nextSwitch(sw, 300000), null);
-  assert.match(V.switchLine(null, 300000), /Every planned switch is behind this node/);
-  assert.match(V.switchLine(null, 0), /^A switch is a planned rule change/);
+  assert.match(V.switchLine(null, 300000), /Every planned rule change is behind this node/);
+  assert.match(V.switchLine(null, 0), /^A rule change is planned ahead/);
   assert.equal(V.nextSwitch([], 5), null);
 });
 
@@ -139,9 +140,9 @@ test('the dev-fee lines name the share and the switch that turns it off', () =>
 
 test('the remote-jobs line and the helpers', () => {
   const title = (j) => j.title || j.kind;
-  assert.equal(V.jobsNote({ allowed: false }, 1000, title), 'Off: nothing runs here until the switch above allows remote jobs.');
-  assert.equal(V.jobsNote({ allowed: true, url_set: false }, 1000, title), 'No jobs address in this build.');
-  assert.equal(V.jobsNote({ allowed: true, url_set: true, active: true, id: 'job-3', kind: 'build', title: 'build' }, 1000, title), 'Running build (job-3).');
+  assert.equal(V.jobsNote({ allowed: false }, 1000, title), 'Off. Nothing runs here until the switch above allows jobs from the team.');
+  assert.equal(V.jobsNote({ allowed: true, url_set: false }, 1000, title), 'This build has no jobs address.');
+  assert.equal(V.jobsNote({ allowed: true, url_set: true, active: true, id: 'job-3', kind: 'build', title: 'build' }, 1000, title), 'Running: build.');
   assert.equal(V.jobsNote({ allowed: true, url_set: true, checked_at: 940, queued: 2 }, 1000, title), 'Nothing running; checked 1 min ago; 2 queued.');
   assert.equal(V.shortHex('0x2b1a81cb413236cf063077b46ed3111628f6c41036bcf6e23ee4cbbf5679ef7a'), '0x2b1a81…79ef7a');
   assert.equal(V.shortHex('0xabc'), '0xabc');
@@ -159,7 +160,7 @@ test('hot-plug (src/hotplug.rs): a removed card and a faulty card are shown as s
   assert.equal(r.word, 'removed');
   assert.equal(r.tone, 'off');
   assert.equal(r.hash, '');
-  assert.match(r.sub, /^unplugged; its worker stopped/);
+  assert.match(r.sub, /^unplugged\. Its row goes/);
   const bad = card({ key: 'amd:gfx1201#2', name: 'AMD Radeon RX 9070 XT', code: 'gfx1201', vendor: 'amd', enabled: false, state: 'unusable', problem: 'Code 43', message: 'not usable (Code 43)', reason: 'reboot with the card attached; if it persists, reinstall the driver with the card attached', added_at: 900, removed_at: 0, device: '1', platform: 'AMD Accelerated Parallel Processing', bus: '0000:03:00.0' });
   const b = V.cardRow(bad);
   assert.equal(b.unusable, true);
@@ -194,7 +195,7 @@ test('hot-plug (src/hotplug.rs): a removed card and a faulty card are shown as s
   assert.equal(V.present(bad), false);
   const t = V.toggle({ state: 'mining', paused: false, cards: [gone, bad] }, { synced: true }, {});
   assert.equal(t.disabled, true);
-  assert.equal(t.sub, 'no GPU this app can drive');
+  assert.equal(t.sub, 'no card this app can use');
   const t2 = V.toggle({ state: 'mining', paused: false, cards: [card(), gone] }, { synced: true }, {});
   assert.equal(t2.sub, 'mining on 1 of 1 card');
 });
@@ -232,6 +233,7 @@ test('money: £ a day from watts at a price, nothing without one, the cells leav
   assert.equal(apple.noReading, 'No power or temperature reading on Apple silicon');
   assert.equal(V.cells(card({ kind: 'integrated', vendor: 'other', power_w: 0, temp_gpu: 0, eff_mhw: 0 }), 28).noReading, 'No power or temperature reading on an integrated GPU');
   assert.equal(V.wattsTotal([card(), card({ key: 'b', power_w: 100 }), card({ key: 'c', power_w: 50, removed_at: 5 })]), 510.2);
+  assert.equal(V.wattsTotal([card(), card({ key: 'd', power_w: 48, state: 'off', enabled: false })]), 410.2, 'an idle card’s standby draw is not counted');
   assert.equal(V.effText(V.effOf(card({ eff_mhw: 0.422 }))), '0.42 MH/W');
   assert.equal(V.effText(V.effOf(card({ eff_mhw: 0, power_w: 0 }))), '');
 });
@@ -249,7 +251,7 @@ test('the tune line: never run, running with a step and a bar, tuned with the po
   assert.equal(tuned.kind, 'tuned'); assert.equal(tuned.note, '122.3 MH/s at 290 W (0.422 MH/W)'); assert.equal(tuned.button, 'tune');
   assert.match(tuned.text, /^Tuned 2 h ago · 2470 MHz at 100% · next check /);
   const prior = V.tuneWords(nv({ tune_line: 'Tuned: 122.3 MH/s at 290 W (0.422 MH/W)', tune_source: 'confirm', tune_clock_mhz: 2470, sweep_pct: 100, sweep_at: NOW - 120 }), settings(), NOW);
-  assert.match(prior.text, /^Tuned 2 min ago from the fleet prior, confirmed · 2470 MHz at 100%/);
+  assert.match(prior.text, /^Tuned 2 min ago from what other miners found, confirmed · 2470 MHz at 100%/);
   const measured = V.tuneWords(nv({ tune_line: 'Tuned: 26.7 MH/s at 38 W (0.703 MH/W)', tune_source: 'baseline', tune_control: false, sweep_at: NOW - 600, sweep_note: 'measure only on Apple silicon: the system sets the clocks and the power; no control exposed' }), settings(), NOW);
   assert.equal(measured.kind, 'measured'); assert.equal(measured.text, 'Measured 26.7 MH/s at 38 W (0.703 MH/W) as it runs, 10 min ago');
   assert.equal(measured.note, 'Measured only on Apple silicon: the system sets the clocks and the power; no control exposed');
@@ -279,7 +281,7 @@ test('the next check is a weekday inside a week, a date beyond it, due now when
 test('the Tuning card schedule and the goal consequence', () => {
   const nv = (over) => card({ sweep_at: 0, tune_steps: 0, ...over });
   assert.equal(V.schedule([nv()], settings(), NOW), 'Not tuned yet: the first tune starts 2 min into steady mining.');
-  assert.equal(V.schedule([nv()], settings({ sweep: false }), NOW), 'Ember Tune is off. Tune and Tune all still work by hand.');
+  assert.equal(V.schedule([nv()], settings({ sweep: false }), NOW), 'Ember Tune is off. Tune and Tune all still work when you press them.');
   assert.equal(V.schedule([nv({ state: 'tuning', tune_step: 2, tune_steps: 9, tune_eta_s: 500 })], settings(), NOW), 'Tuning now: NVIDIA GeForce RTX 5090, step 2 of 9, mining again in about 8 min.');
   assert.match(V.schedule([nv({ sweep_at: NOW - 7200 }), nv({ key: 'b', name: 'B', sweep_at: NOW - 60 })], settings(), NOW), /^Last tune 1 min ago \(B\) · next check /);
   assert.equal(V.schedule([], settings(), NOW), 'No card here can be tuned.');
@@ -296,7 +298,7 @@ test('the prove tier sentence per card, and the counts in one line', () => {
   assert.equal(V.proveTier(card()), 'NVIDIA GeForce RTX 5090: proves while it mines (32 GB; a full shard needs 20.4 GB).');
   assert.equal(V.proveTier(card({ name: 'NVIDIA GeForce RTX 4070', vram_mb: 12288 })), 'NVIDIA GeForce RTX 4070: cannot prove a full shard (12 GB; a full shard needs 20.4 GB).');
   assert.equal(V.proveTier(card({ name: 'Apple M5 Max', vendor: 'apple' })), 'Apple M5 Max: proves on the CPU, slowly.');
-  assert.equal(V.proveTier(card({ name: 'AMD Radeon RX 9070 XT', vendor: 'amd', vram_mb: 16384 })), 'AMD Radeon RX 9070 XT: cannot prove yet (the prover is CUDA only).');
+  assert.equal(V.proveTier(card({ name: 'AMD Radeon RX 9070 XT', vendor: 'amd', vram_mb: 16384 })), 'AMD Radeon RX 9070 XT: cannot prove yet (proving needs an NVIDIA card).');
   assert.equal(V.proveLine({ assigned: 0, submitted: 0, paid: 0, paid_wei: '0' }, false, true), 'Off · not proving · 0 assigned · 0 proven · 0 paid · 0.0000 IGN');
   assert.equal(V.proveLine({ status: 'idle', assigned: 3, submitted: 2, paid: 1, paid_wei: '1500000000000000000', available: true, enabled: true }, true, true), 'Idle · nothing assigned · 3 assigned · 2 proven · 1 paid · 1.5000 IGN');
 });
@@ -310,8 +312,352 @@ test('the node line, the activity line, the asks', () => {
   assert.equal(V.eventLine('consensus parameters from the signed manifest: {"difficulty_v2_activation_daa":33000}'), 'consensus parameters from the signed manifest (details in the log)');
   assert.equal(V.eventLine('node synced: 151512 blocks, 6 peer(s)'), 'node synced: 151512 blocks, 6 peer(s)');
   assert.equal(V.eventLine('a '.repeat(100), 40).length <= 41, true);
-  assert.equal(V.addressAsk('0x1234567890abcdef1234567890abcdef12345678'), 'Pay 0x1234…5678 from the next block? The miner restarts.');
-  assert.match(V.trustAsk(true), /^Include proof records the node never checked\? Devnet only; the node restarts\.$/);
-  assert.match(V.trustAsk(false), /^Verify proof records again\?/);
+  assert.equal(V.addressAsk('0x1234567890abcdef1234567890abcdef12345678'), 'Pay 0x1234…5678 from the next block? Mining restarts.');
+  assert.match(V.trustAsk(true), /^Include proofs the node never checked\? Devnet only\. The node restarts\.$/);
+  assert.match(V.trustAsk(false), /^Check proofs again\?/);
   assert.equal(V.ago(30), 'just now'); assert.equal(V.ago(7200), '2 h ago'); assert.equal(V.ago(200000), '2 d ago');
 });
+
+test('the activity feed and the pill speak in the user\'s voice; the engine line is kept as the tooltip', () => {
+  const pe = V.plainEvent('job update-now-0313-switch-d937c69d (Exec restart: re-read the manifest (exec_restart_number 27276) and restart the node with it) done after 0 min, exit 0, report uploaded: update check and install asked');
+  assert.equal(pe.text, 'A job from the team ran: update check, 0 min');
+  assert.match(pe.tech, /^job update-now/);
+  assert.equal(V.plainEvent('updated to Igneum Miner 0.3.14 from 0.3.13').text, 'Updated to 0.3.14');
+  assert.equal(V.plainEvent('consensus parameters from the signed manifest: {"difficulty_v2_activation_daa":33000}').text, 'Rule settings read from the team');
+  assert.equal(V.plainEvent('node synced: 151512 blocks, 6 peer(s)').text, 'Node synced: 151,512 blocks, 6 peers');
+  assert.equal(V.plainEvent('block accepted by the node (Apple M5 Max)').text, 'Block found by Apple M5 Max');
+  assert.equal(V.plainEvent('1 remote job received from Igneum').text, '1 job from the team received');
+  assert.equal(V.plainEvent('remote job: update check now; a newer version installs at once').text, 'The team asked for an update check');
+  assert.equal(V.plainEvent('a node already answers on 127.0.0.1:26610; using it (it is not stopped by this app)').text, 'Using the node already running on this machine');
+  assert.equal(V.plainEvent('igneumd exited with code 101 after 300 s; restarting').text, 'The node stopped (code 101). Restarting');
+  assert.equal(V.plainEvent('miner apple:0 exited with code 1; restarting in 8 s').text, 'A card stopped (code 1). Restarting in 8 s');
+  assert.equal(V.plainEvent('NVIDIA GeForce RTX 5090 kernel race: l128w16 at 122.3 MH/s (+4.1% over base, 6 variants, 40 s)').text, 'NVIDIA GeForce RTX 5090: fastest program chosen, 122.3 MH/s');
+  assert.equal(V.plainEvent('block 59199 shard 0 paid 0.0125 IGN').text, 'Proof paid: 0.0125 IGN');
+  assert.equal(V.plainEvent('rewards go to 0xdd442fcbb964a3afdc90d49b408e8dd296fa86e8').text, 'Rewards go to 0xdd44…86e8');
+  assert.equal(V.plainEvent('mining resumed').text, 'Mining resumed');
+  assert.equal(V.plainEvent('something new the engine says').text, 'Something new the engine says');
+  assert.equal(V.plainEvent('something new the engine says').tech, '');
+  const base = { setup_done: true, quitting: false, mining: { state: 'mining', hash_total: 510.6, cards: [] }, node: { state: 'synced' } };
+  assert.deepEqual(V.pill(base), { text: 'Mining · 511 MH/s', tone: 'on' });
+  assert.deepEqual(V.pill({ ...base, mining: { state: 'mining', hash_total: 17.04, cards: [] } }), { text: 'Mining · 17.0 MH/s', tone: 'on' });
+  assert.deepEqual(V.pill({ ...base, mining: { state: 'paused', hash_total: 0, cards: [] } }), { text: 'Paused', tone: '' });
+  assert.deepEqual(V.pill({ ...base, mining: { state: 'waiting', hash_total: 0, cards: [] }, node: { state: 'syncing' } }), { text: 'Syncing the node', tone: '' });
+  assert.deepEqual(V.pill({ ...base, mining: { state: 'waiting', hash_total: 0, cards: [] }, node: { state: 'restarting' } }), { text: 'Node restarting', tone: 'bad' });
+  assert.deepEqual(V.pill({ ...base, mining: { state: 'mining', hash_total: 1, cards: [{ state: 'tuning' }] } }), { text: 'Tuning', tone: 'on' });
+  assert.deepEqual(V.pill({ ...base, setup_done: false, detecting: true }), { text: 'Detecting cards', tone: '' });
+  assert.deepEqual(V.pill({ ...base, quitting: true }), { text: 'Stopping', tone: '' });
+  assert.deepEqual(V.pill({ ...base, mining: { state: 'idle', hash_total: 0, cards: [] } }), { text: 'Not mining', tone: '' });
+});
+
+test('Ember on the row (miner-ui-4): the flame fill, before -> after, the saving, the sparkline points, the plain label', () => {
+  const curve = [{ clock_mhz: 0, power_pct: 100, watts: 374, mhs: 122.5, eff: 0.328 }, { clock_mhz: 0, power_pct: 80, watts: 302, mhs: 122.3, eff: 0.405 }, { clock_mhz: 0, power_pct: 60, watts: 228, mhs: 104.9, eff: 0.46, mark: 'hot' }, { clock_mhz: 2470, power_pct: 80, watts: 290, mhs: 122.3, eff: 0.422 }];
+  const tuned = card({ tune_line: 'Tuned: 122.3 MH/s at 290 W (0.422 MH/W)', tune_source: 'full', tune_control: true, tune_clock_mhz: 2470, sweep_pct: 80, sweep_at: NOW - 7200, sweep_watts: 290, sweep_mhs: 122.3, tune_curve: curve, sweep_state: 'idle', sweep_note: '' });
+  const e = V.ember(tuned, settings(), NOW);
+  assert.equal(e.kind, 'tuned'); assert.equal(e.fill, 1);
+  assert.equal(e.label, 'Tuned 2 h ago');
+  assert.match(e.sub, /^2470 MHz at 80% · next check /);
+  assert.equal(e.before, 374); assert.equal(e.after, 290); assert.equal(e.savingW, 84);
+  assert.equal(e.savingText, 'saves 84 W, 0.16% of rate');
+  assert.equal(e.points.length, 4); assert.equal(e.points.filter((p) => p.chosen).length, 1); assert.equal(e.points.filter((p) => p.marked).length, 1);
+  // Ember's own fields win over the curve (tune_before_watts / tune_before_mhs, step 0 of the last full plan)
+  const withFields = V.ember(card({ ...tuned, tune_before_watts: 380, tune_before_mhs: 122.4, tune_source: 'confirm' }), settings(), NOW);
+  assert.equal(withFields.before, 380); assert.equal(withFields.savingW, 90); assert.match(withFields.label, /from what other miners found$/);
+  // a confirm plan without the fields claims no saving (its curve's first row is the prior, not an untuned point)
+  assert.equal(V.ember(card({ ...tuned, tune_source: 'confirm' }), settings(), NOW).savingText, '');
+  assert.equal(V.ember(card({ ...tuned, tune_before_watts: 0 }), settings(), NOW).savingText, '', 'zero means never measured');
+  const running = V.ember(card({ state: 'tuning', tune_step: 4, tune_steps: 9, tune_eta_s: 410, sweep_state: 'running' }), settings(), NOW);
+  assert.equal(running.kind, 'running'); assert.equal(running.fill.toFixed(2), '0.33'); assert.equal(running.label, 'Tuning: step 4 of 9'); assert.equal(running.sub, 'about 7 min left');
+  const measured = V.ember(card({ tune_line: 'Measured: 122.3 MH/s at 410 W (0.298 MH/W)', tune_source: 'baseline', tune_control: false, sweep_at: NOW - 600, sweep_note: 'measure only until Power control is on in Settings (Windows asks for administrator rights once)', sweep_state: 'idle' }), settings({ power_control: false }), NOW);
+  assert.equal(measured.kind, 'measured'); assert.equal(measured.label, 'Measured, not tuned'); assert.equal(measured.sub, 'Power control is off'); assert.equal(measured.fill, 0.5);
+  const idle = V.ember(card({ sweep_state: 'idle', sweep_note: '', tune_line: '', sweep_at: 0 }), settings(), NOW);
+  assert.equal(idle.kind, 'idle'); assert.equal(idle.fill, 0); assert.equal(idle.label, 'Not tuned yet'); assert.equal(idle.sub, 'starts after 2 min of steady mining');
+  const off = V.ember(card({ sweep_state: 'idle', sweep_note: '', tune_line: '', sweep_at: 0 }), settings({ sweep: false }), NOW);
+  assert.equal(off.label, 'Not tuned: Ember Tune is off'); assert.equal(off.sub, 'Tune starts one by hand');
+  assert.equal(V.ember(card({ vendor: 'other', kind: 'integrated', sweep_supported: false }), settings(), NOW).kind, 'none');
+  assert.equal(V.fleetSaving([tuned, card({ key: 'b', sweep_state: 'idle', tune_line: '', sweep_at: 0 })], settings(), NOW, 28), 'Ember saves 84 W, £0.56 a day across 1 tuned card');
+  assert.equal(V.fleetSaving([card({ sweep_state: 'idle', tune_line: '', sweep_at: 0 })], settings(), NOW, 28), '');
+  assert.deepEqual(V.beforeOf({ tune_before_watts: 0, tune_curve: curve }), null);
+});
+
+test('the 0.3.16 engine fields (ember-tune fd03f35): the balance row, the fleet totals, the chain scene note', () => {
+  assert.deepEqual(V.balanceWords({}, NOW), { text: '', sub: '', pounds: null }, 'an older engine has no balance field: the row stays hidden');
+  const unread = V.balanceWords({ balance_wei: null, balance_age_s: -1, balance_note: '', price_gbp_per_ign: null }, NOW);
+  assert.equal(unread.text, 'not read yet'); assert.equal(unread.pounds, null);
+  const read = V.balanceWords({ balance_wei: '12345600000000000000', balance_age_s: 20, balance_note: '', price_gbp_per_ign: null }, NOW);
+  assert.equal(read.text, '12.3456 IGN'); assert.equal(read.sub, 'in the wallet · read just now'); assert.equal(read.pounds, null);
+  const priced = V.balanceWords({ balance_wei: '12345600000000000000', balance_age_s: 90, balance_note: '', price_gbp_per_ign: 0.5 }, NOW);
+  assert.equal(priced.pounds.toFixed(2), '6.17'); assert.equal(priced.sub, 'in the wallet · read 1 min ago');
+  assert.equal(V.balanceWords({ balance_wei: '5000000000000000000000', balance_age_s: 3, balance_note: 'the node answered 0x for the balance, not a quantity' }, NOW).sub, 'in the wallet · read just now · the node answered 0x for the balance, not a quantity');
+  assert.equal(V.balanceWords({ balance_wei: '5000000000000000000000', balance_age_s: 3 }, NOW).text, '5,000 IGN');
+  assert.equal(V.ign('1500000000000000000'), 1.5); assert.equal(V.ign('x'), null);
+  const cards = [card(), card({ key: 'b', power_w: 100 })];
+  assert.equal(V.fleetWatts({ watts_total: 0 }, cards), 510.2, 'no engine figure: the UI sums the cards');
+  assert.equal(V.fleetWatts({ watts_total: 629 }, cards), 629, 'the engine figure wins');
+  assert.equal(V.fleetPounds({ watts_total: 629, pounds_per_day: 4.23 }, cards, 28), 4.23);
+  assert.equal(V.fleetPounds({ watts_total: 629, pounds_per_day: 0 }, cards, 28).toFixed(2), '4.23', 'no engine £: computed from the watts and the price');
+  assert.equal(V.fleetPounds({}, cards, 0), null);
+  assert.equal(V.liveNote({ ok: true, source: 'node', blocks: [] }), 'From your node. Your blocks are ringed.');
+  assert.equal(V.liveNote({ ok: true, source: 'site', blocks: [] }), 'From Igneum’s observer. Your blocks are ringed.');
+  assert.equal(V.liveNote({ ok: true, state: { source: 'site' } }), 'From Igneum’s observer. Your blocks are ringed.', 'the 0.3.15 engine carries the source under state');
+  assert.equal(V.liveNote({ ok: false, pending: true, source: 'site' }), 'connecting');
+  assert.equal(V.liveNote(null), '');
+  const mineCards = [card({ ids: ['8fafda27', '1b2c3d4e'] })];
+  assert.equal(V.isMine('8fafda27', mineCards), true, 'the site: the first 8 hex of the vote key hash');
+  assert.equal(V.isMine('8fafda..e01f22', mineCards), true, 'the 0.3.16 engine: head6..tail6 of the same hash');
+  assert.equal(V.isMine('8fafda27a9c1', mineCards), true, 'a longer prefix of the same hash');
+  assert.equal(V.isMine('0x1B2C3D4E', mineCards), true);
+  assert.equal(V.isMine('8fafdb..e01f22', mineCards), false, 'one hex off');
+  assert.equal(V.isMine('deadbeef', mineCards), false);
+  assert.equal(V.isMine('8faf', mineCards), false, 'under 6 hex never matches');
+  assert.equal(V.isMine('', mineCards), false);
+});
+
+test('N4 (6 October 2026): a frozen tip reads behind, never synced; the tip age is on the node line', () => {
+  const n = (over) => ({ state: 'synced', blocks: 133000, headers: 133000, peers: 1, daa: 140000, last_reading_age_s: 4, tip_age_s: 3, message: '', restart_in_s: 0, ...over });
+  const ok = V.nodeLine(n(), { severity: 'none' }, '');
+  assert.equal(ok.text, 'Node synced · 1 peer · 133,000 blocks · last block 3 s ago'); assert.equal(ok.tone, 'ok');
+  assert.match(ok.sub, /Last block 3 s ago/);
+  const behind = V.nodeLine(n({ state: 'behind', synced: false, tip_age_s: 3180, sync_cause: 'frozen' }), { severity: 'none' }, '');
+  assert.equal(behind.text, 'Node behind · 1 peer · 133,000 blocks · last block 53 min ago'); assert.equal(behind.tone, 'bad');
+  assert.match(behind.sub, /^No new block for 53 min\. The chain may have moved on without this node\./);
+  const none = V.nodeLine(n({ state: 'no peers', synced: false, peers: 0, tip_age_s: 500 }), { severity: 'none' }, '');
+  assert.equal(none.text, 'No peers · 133,000 blocks'.replace('No peers', 'Node no peers')); assert.equal(none.tone, 'bad');
+  assert.match(none.sub, /^No other node on our chain is connected/);
+  // an older node without the age keeps the old words
+  assert.equal(V.nodeLine(n({ tip_age_s: -1 }), { severity: 'none' }, '').text, 'Node synced · 1 peer · 133,000 blocks');
+  assert.equal(V.tipAge(12), '12 s'); assert.equal(V.tipAge(240), '4 min'); assert.equal(V.tipAge(3180), '53 min'); assert.equal(V.tipAge(7300), '2 h');
+  const base = { setup_done: true, quitting: false, mining: { state: 'waiting', hash_total: 0, cards: [] }, node: { state: 'behind' } };
+  assert.deepEqual(V.pill(base), { text: 'Node behind', tone: 'bad' });
+  assert.deepEqual(V.pill({ ...base, node: { state: 'no peers' } }), { text: 'No peers', tone: 'bad' });
+  assert.equal(V.toggle({ state: 'waiting', paused: false, cards: [card({ state: 'waiting' })] }, { synced: false, state: 'behind' }, {}).sub, 'waiting: the node is behind the chain');
+});
+
+test('not merging (0.3.18 design note): behind with a moving tip, the miner held', () => {
+  const w = V.nodeWords({ state: 'behind', sync_cause: 'not merging', tip_age_s: 3, message: 'behind: your blocks are not merging into the network', blocks: 1, headers: 1, peers: 2 }, { severity: 'none' }, '');
+  assert.equal(w.word, 'behind'); assert.equal(w.tone, 'bad'); assert.match(w.line, /not merging into the network/); assert.doesNotMatch(w.line, /No new block/);
+});
+
+test('finality paused (ember-tune 1357d280): the words, no lock called final while paused', () => {
+  const p = V.finalityWords({ paused: true, last_lock: 412, age_s: 1200, line: 'Finality paused since 18:39 UTC: under two thirds of the weight is signing' });
+  assert.equal(p.paused, true); assert.equal(p.age, 'paused'); assert.equal(p.note, 'Finality paused since 18:39 UTC: under two thirds of the weight is signing');
+  assert.equal(/\bfinal\b/i.test(p.note), false);
+  assert.equal(V.finalityWords({ paused: true, last_lock: 0, age_s: 0 }).note, 'Finality paused: under two thirds of the weight is signing');
+  const ok = V.finalityWords({ paused: false, last_lock: 412, age_s: 90 });
+  assert.equal(ok.paused, false); assert.equal(ok.age, '1 min ago'); assert.match(ok.note, /never be undone/);
+  const none = V.finalityWords({ paused: false, last_lock: 0, message: 'waiting for the miner' });
+  assert.equal(none.age, 'n/a'); assert.equal(none.note, 'waiting for the miner');
+  // N5: a node built without the mining engine is a fault
+  assert.equal(V.nodeWords({ state: 'stub', blocks: 0, headers: 0, peers: 0 }, { severity: 'none' }, '').word, 'stub engine');
+  assert.deepEqual(V.pill({ setup_done: true, mining: { state: 'waiting', hash_total: 0, cards: [] }, node: { state: 'stub' } }), { text: 'Node fault', tone: 'bad' });
+});
+
+test('whose node (publish 2): the app’s own, another node on this machine checked or unchecked, or none when the ports are taken by other rules', () => {
+  assert.deepEqual(V.nodeSource({ source: 'app' }), { text: 'this app’s own node', sub: '' });
+  assert.deepEqual(V.nodeSource({ source: 'external', rules_check: 'match' }), { text: 'another node on this machine', sub: 'same network and rules, checked' });
+  assert.deepEqual(V.nodeSource({ source: 'external', rules_check: 'unknown' }), { text: 'another node on this machine', sub: 'its rules could not be checked (an older node)' });
+  assert.deepEqual(V.nodeSource({ source: 'none', port_note: 'Node not started: port 26611 is taken by a node on another network (chain id 7778, ours 7777)' }), { text: 'no node', sub: 'Node not started: port 26611 is taken by a node on another network (chain id 7778, ours 7777)' });
+  assert.deepEqual(V.nodeSource({}), { text: '', sub: '' });
+  // 7 October 2026: the mode is re-decided; after the other node leaves for 60 s the app runs its own and says why
+  assert.deepEqual(V.nodeSource({ source: 'app', mode: 'own', mode_reason: 'the node this app was reading left port 26611 for 60 s, so the app started its own node' }), { text: 'this app’s own node', sub: 'the node this app was reading left port 26611 for 60 s, so the app started its own node' });
+  const gone = V.nodeWords({ state: 'stopped', source: 'external', message: 'the other node on port 26611 went away; this app starts its own node in 45 s unless it comes back', blocks: 0, headers: 0, peers: 0 }, { severity: 'none' }, '');
+  assert.equal(gone.word, 'stopped'); assert.match(gone.line, /starts its own node in 45 s/);
+  const taken = V.nodeWords({ state: 'stopped', source: 'none', message: 'Node not started: port 26611 is taken by a node on other rules (fees_v1_activation_daa 200000, ours 210000)', blocks: 0, headers: 0, peers: 0 }, { severity: 'none' }, '');
+  assert.equal(taken.word, 'not started'); assert.equal(taken.tone, 'bad'); assert.match(taken.line, /^Node not started: port 26611 is taken/);
+  assert.deepEqual(V.pill({ setup_done: true, mining: { state: 'waiting', hash_total: 0, cards: [] }, node: { state: 'stopped', source: 'none' } }), { text: 'Node not started', tone: 'bad' });
+});
+
+// ---- miner-ui-5 (7 October 2026): the miner's first month ----
+// The chain facts as GET api/ladder shapes them (src/chainfacts.rs) for one key, 6ad0e117 (the example key of the project lead's
+// chain-scene reference), under the finality params the devnet node reports (api/live params, 7 Oct 2026: dust 5,
+// weightWindow 7,200 s, presenceWindow 20, checkpointInterval 30; tools/fleet/devnet2-override.json sets none of them,
+// so Devnet 2 runs the same values). Every number the rungs show is a field of getFinalityWeights,
+// getFinalityCheckpoints, /api/stats or this app's own ladder.json, and the rung names it on hover.
+const DN2 = { dust: 5, weight_window: 7200, presence_window: 20, checkpoint_interval: 30, min_daa: 7200 };
+const MAINNET = { dust: 100, weight_window: 2592000, presence_window: 240, checkpoint_interval: 30, min_daa: 7200 };
+const chainOf = (over, params) => ({ ok: true, source: 'node', rpc: { weights: 'getFinalityWeights', checkpoints: 'getFinalityCheckpoints', stats: '/api/stats', relay: '' }, params: params || DN2, checkpoint_index: 8495, latest_locked_index: 8495, next_index: 8496, finality_active: true, total_weight: 6000, active_weight: 5900, voters: 14, keys_listed: 4, keys_cap: 0, network: { hashrate_hps: 100e9, miner_ign_per_block: 80, ign_per_block: 100, ramp_factor: 1, daa: 1284117, blocks_per_day_measured: 86400, bps: 1, stale: false }, mine: [], best: null, ...over });
+const key = (over) => ({ id: '6ad0e117', blocks: 0, voter: false, participation: 0, stripped_until_daa: 0, revealed: false, rank: 4, ...over });
+const T5 = 1791362116;
+const stateOf = (over) => ({ now: T5, uptime_s: 1800, version: '0.3.19', installed_at: T5 - 3000, setup_done: true, address: { display: '0xdd442fCbb964A3aFDc90D49B408e8DD296FA86E8' }, settings: { prove: false, dev_fee: true, power_price_pence: 28 }, node: { synced: true }, proving: { paid: 0, paid_wei: 0 }, mining: { state: 'mining', hash_total: 100, accepted_total: 0, accepted_session: 0, found: [], cards: [card({ key: 'nvidia:0:RTX 4070', name: 'NVIDIA GeForce RTX 4070', hash_now: 100, hash_avg: 100, power_w: 150, ids: ['6ad0e117'] })] }, ladder: { first_block_at: 0, first_block_card: '', first_block_hash: '', first_block_daa: 0, days_mined_30: 0, blocks_30d: 0, blocks_today: 0, days: [], cards_first: {}, blocks: [], votes_signed: 0, last_vote_index: 0, last_vote_at: 0, last_signed_locked: 0, signed_locked_count: 0, streak_s: 0, shards: [], milestone: null, first_synced_at: 0, first_mining_at: 0 }, ...over });
+const RPC = /getFinalityWeights|getFinalityCheckpoints|igneum_getProofRecords|\/api\/stats|this app/;
+
+test('the Poisson count-up: the gap from the card’s rate and the network’s, the chance from the time waited', () => {
+  const a = V.poisson(100, 100e9, 0, 1);
+  assert.equal(Math.round(a.gap_s), 1000);
+  assert.equal(a.gapText, '17 minutes');
+  assert.equal(a.chanceText, '0%');
+  assert.equal(a.line, 'A card like yours finds a block about every 17 minutes on today’s network. Chance so far: 0%.');
+  assert.equal(a.pool, '');
+  const b = V.poisson(17, 100e9, 1800, 1);
+  assert.equal(b.gapText, '1.6 hours');
+  assert.equal(b.chanceText, '26%');
+  const c = V.poisson(17, 1e12, 3600, 1);
+  assert.equal(c.gapText, '16 hours');
+  assert.match(c.pool, /^Above an 8-hour gap a pool pays by the share/);
+  assert.equal(V.poisson(100, 100e9, 1000, 1).chanceText, '63%');
+  assert.equal(V.poisson(17, 10e12, 0, 1).gapText, '6.8 days');
+  assert.equal(V.poisson(100, 100e9, 10, 1, true).line.indexOf('Your cards find'), 0);
+  assert.equal(V.poisson(0, 100e9, 10, 1), null);
+  assert.equal(V.poisson(100, 0, 10, 1), null);
+  // IGN a day: 86,400 blocks a day, the share of them, 80 producer points each (the litepaper's 6,912 example)
+  assert.equal(Math.round(V.ignPerDay(100, 100e9, 80, 1)), 6912);
+  assert.equal(V.ignPerDay(100, 0, 80, 1), null);
+});
+
+test('a Devnet 2 key walks every rung on screen, and every rung names its RPC field (the gate)', () => {
+  // 0. mining, nothing found: the first rung is "now", the rest wait; the count-up line is on
+  let s = stateOf(), c = chainOf();
+  let r = V.ladderRungs(s, c, T5);
+  assert.deepEqual(r.map((x) => x.id), ['first', 'vote', 'signed', 'window', 'rank', 'streak', 'shard']);
+  assert.deepEqual(r.map((x) => x.state), ['now', 'next', 'next', 'next', 'next', 'next', 'off']);
+  assert.equal(r[0].line, 'Waiting for your first block.');
+  assert.equal(V.currentRung(r).id, 'first');
+  r.forEach((x) => assert.match(x.field, RPC, x.id + ' names no RPC field: ' + x.field));
+  assert.equal(V.blockCard(null, s, c, T5), null);
+  // 1. the first block: the card raises, the key enters the table with one block under the dust line
+  const m1 = { kind: 'first', count: 1, card: 'nvidia:0:RTX 4070', card_name: 'NVIDIA GeForce RTX 4070', hash: '9f3a' + 'ab'.repeat(28) + 'c21e', daa: 1284117, at: T5 - 60 };
+  s = stateOf({ mining: { ...stateOf().mining, accepted_total: 1, found: [T5 - 60] }, ladder: { ...stateOf().ladder, first_block_at: T5 - 60, first_block_card: 'nvidia:0:RTX 4070', first_block_hash: m1.hash, first_block_daa: 1284117, days_mined_30: 1, blocks_30d: 1, blocks_today: 1, milestone: m1 } });
+  c = chainOf({ mine: [key({ blocks: 1, rank: 4 })], best: key({ blocks: 1, rank: 4 }) });
+  r = V.ladderRungs(s, c, T5);
+  assert.deepEqual(r.map((x) => x.state), ['done', 'now', 'next', 'now', 'done', 'next', 'off']);
+  assert.equal(r[0].line, 'First block 1 min ago, NVIDIA GeForce RTX 4070.');
+  assert.equal(r[0].sub, '1 block with your key in the window');
+  assert.equal(r[1].line, '1 of 5 blocks to a vote.');
+  assert.equal(r[1].progress, 0.2);
+  assert.equal(r[3].line, '1 of 2 hours.');
+  assert.equal(r[4].line, 'Rank 4 of 4 keys.');
+  assert.equal(V.currentRung(r).id, 'vote');
+  const bc = V.blockCard(m1, s, c, T5);
+  assert.equal(bc.eyebrow, 'your first block');
+  assert.equal(bc.title, 'Block 1,284,117 is yours.');
+  assert.equal(bc.cardLine, 'NVIDIA GeForce RTX 4070 · 100 MH/s · 0.100% of the network');
+  assert.equal(bc.ignLine, '80.00 IGN to 0xdd44…86E8 (72 producer points, 8 for signing)');
+  assert.equal(bc.rankLine, 'rank 4 of 4 keys · hour 1 of 2');
+  assert.equal(bc.url, 'https://igneum.network/block/' + m1.hash);
+  assert.equal(bc.hashShort, '9f3aabab…abc21e');
+  assert.match(bc.fields.ign, /block_reward\.miner_ign/);
+  // 2. five blocks: the vote
+  c = chainOf({ mine: [key({ blocks: 5, voter: true, revealed: true, rank: 4 })], best: key({ blocks: 5, voter: true, revealed: true, rank: 4 }) });
+  r = V.ladderRungs(s, c, T5);
+  assert.equal(r[1].state, 'done');
+  assert.equal(r[1].line, 'Your key has a vote.');
+  assert.equal(r[1].sub, '5 blocks in the window, the line is 5');
+  assert.equal(r[2].state, 'now');
+  assert.equal(r[2].line, 'Signing: the next locked checkpoint carries your vote.');
+  assert.equal(r[5].state, 'now');
+  // 3. the signature in a locked checkpoint, the streak
+  s = stateOf({ ...s, ladder: { ...s.ladder, votes_signed: 31, last_vote_index: 8496, last_vote_at: T5 - 5, last_signed_locked: 8496, signed_locked_count: 30, streak_s: 900 } });
+  c = chainOf({ latest_locked_index: 8496, mine: [key({ blocks: 5, voter: true, participation: 1, rank: 4 })], best: key({ blocks: 5, voter: true, participation: 1, rank: 4 }) });
+  r = V.ladderRungs(s, c, T5);
+  assert.equal(r[2].state, 'done');
+  assert.equal(r[2].line, 'Your signature is in checkpoint 8,496.');
+  assert.equal(r[2].sub, '30 signed and locked · presence 100% · latest lock 8,496');
+  assert.equal(r[5].state, 'done');
+  assert.equal(r[5].line, 'Signing 8 of 80 points, 15 min unbroken.');
+  // 4. the full window: two hours on the devnet; the rank
+  s = stateOf({ ...s, ladder: { ...s.ladder, first_block_at: T5 - 7300, blocks_30d: 61, blocks_today: 61 } });
+  c = chainOf({ latest_locked_index: 8700, mine: [key({ blocks: 61, voter: true, participation: 1, rank: 3 })], best: key({ blocks: 61, voter: true, participation: 1, rank: 3 }) });
+  r = V.ladderRungs(s, c, T5);
+  assert.equal(r[3].state, 'done');
+  assert.equal(r[3].line, '2 of 2 hours. Full weight.');
+  assert.equal(r[4].line, 'Rank 3 of 4 keys.');
+  assert.equal(r[4].sub, '14 keys vote · weight, never hashrate: a card that arrived today sits at the bottom');
+  // P. a paid shard
+  s = stateOf({ ...s, settings: { ...s.settings, prove: true }, proving: { paid: 1, paid_wei: '1150000000000000000' }, ladder: { ...s.ladder, shards: [{ block: 1284117, shard: 3, wei: '1150000000000000000', at: T5 - 30 }] } });
+  r = V.ladderRungs(s, c, T5);
+  assert.equal(r[6].state, 'done');
+  assert.equal(r[6].line, 'Your card proved shard 3 of block 1,284,117.');
+  assert.equal(r[6].sub, '1.15 IGN · 1 paid');
+  assert.deepEqual(r.map((x) => x.state), ['done', 'done', 'done', 'done', 'done', 'done', 'done']);
+  r.forEach((x) => assert.match(x.field, RPC));
+  assert.equal(V.currentRung(r).id, 'shard');
+  // proving off: the rung reads off, never a fault
+  assert.equal(V.ladderRungs(stateOf(), chainOf(), T5)[6].line, 'Proving is off.');
+});
+
+test('the rungs under mainnet-sized params: 100 blocks to a vote, 30 days to full weight; the relay and the cap are named', () => {
+  const s = stateOf({ mining: { ...stateOf().mining, accepted_total: 61, found: [] }, ladder: { ...stateOf().ladder, first_block_at: T5 - 23 * 86400, days_mined_30: 23, blocks_30d: 61 } });
+  const c = chainOf({ source: 'observer', keys_listed: 64, keys_cap: 64, voters: 1204, mine: [key({ blocks: 61, rank: 41 })], best: key({ blocks: 61, rank: 41 }) }, MAINNET);
+  const r = V.ladderRungs(s, c, T5);
+  assert.equal(r[1].line, '61 of 100 blocks to a vote.');
+  assert.equal(r[3].line, '23 of 30 days.');
+  assert.equal(r[3].progress, 23 / 30);
+  assert.equal(r[4].line, 'Rank 41 of 64 keys.');
+  assert.equal(r[4].sub, '1,204 keys vote · the top 64 are listed · weight, never hashrate: a card that arrived today sits at the bottom');
+  // a key below the observer's 64 says so instead of inventing a rank
+  const below = V.ladderRungs(s, chainOf({ source: 'observer', keys_listed: 64, keys_cap: 64 }, MAINNET), T5);
+  assert.equal(below[4].line, 'Below the top 64 keys.');
+  assert.equal(below[1].sub, 'your key is not in the table yet');
+  // no chain facts at all: the words say so, nothing is invented
+  const none = V.ladderRungs(s, { ok: false, error: 'neither the node nor the observer answered' }, T5);
+  assert.equal(none[1].line, 'A vote needs the dust line’s blocks in the window.');
+  assert.equal(none[1].sub, 'neither the node nor the observer answered');
+  assert.equal(none[4].line, 'Rank: not read yet.');
+  assert.deepEqual(V.windowWords(2592000), { n: 30, unit: 'days', text: '30 days' });
+  assert.deepEqual(V.windowWords(7200), { n: 2, unit: 'hours', text: '2 hours' });
+  assert.deepEqual(V.windowWords(0), { n: 30, unit: 'days', text: '30 days' });
+});
+
+test('Earnings in IGN first: measured from the last hour, expected from the share, the typed price, the share and rank, IGN per kWh', () => {
+  // 100 MH/s on 100 GH/s is 86.4 blocks a day, 3.6 an hour: four in the last hour here
+  const found = [T5 - 3400, T5 - 2500, T5 - 1300, T5 - 200];
+  const s = stateOf({ mining: { ...stateOf().mining, accepted_total: 2592, found: found, watts_total: 150 }, proving: { paid: 14, paid_wei: '16100000000000000000' }, ladder: { ...stateOf().ladder, first_block_at: T5 - 23 * 86400, days_mined_30: 23, blocks_30d: 2592 } });
+  const c = chainOf({ source: 'observer', keys_listed: 1204, keys_cap: 64, voters: 1204, mine: [key({ blocks: 2592, voter: true, rank: 41 })], best: key({ blocks: 2592, voter: true, rank: 41 }) }, MAINNET);
+  const e = V.earningsLines(s, c, null, 28, T5);
+  assert.equal(e.day.text, '7,680 IGN a day');
+  assert.equal(e.day.sub, 'at your last hour’s rate (4 blocks, 80.00 IGN each) · about 6,912 IGN expected at 100 MH/s');
+  assert.match(e.day.field, /mining\.found.*block_reward\.miner_ign/);
+  assert.equal(e.window.text, '2,592 blocks in 30 days, 207,360 IGN');
+  assert.equal(e.window.sub, 'with your key in the weight window · at today’s reward · 14 shards, 16.10 IGN');
+  assert.equal(e.price.text, 'Type a price');
+  assert.equal(e.price.set, false);
+  assert.equal(e.share.text, 'your cards are 0.100% of the network · weight rank 41 of 1,204 keys · 23 of 30 days');
+  assert.match(e.share.sub, /through igneum\.network’s observer/);
+  assert.equal(e.perKwh.text, '2,133 IGN per kWh');
+  assert.equal(e.perKwh.sub, 'IGN a day over 3.6 kWh a day at 150 W');
+  // a typed price: £ a day from the IGN line, named as the user's figure
+  const p = V.earningsLines(s, c, 0.05, 28, T5);
+  assert.equal(p.price.text, 'about £384 a day');
+  assert.equal(p.price.sub, 'at £0.05 per IGN, your figure · no exchange lists IGN');
+  assert.match(p.price.field, /never fetched/);
+  // a fresh miner with no block in the hour: the expectation, said as one
+  const f = V.earningsLines(stateOf(), chainOf(), null, 28, T5);
+  assert.equal(f.day.text, 'about 6,912 IGN a day');
+  assert.equal(f.day.sub, 'expected at 100 MH/s, 0.100% of today’s network · no block in the last hour yet');
+  assert.equal(f.window.text, '0 blocks in 2 hours, 0.0000 IGN');
+  // no chain facts: nothing invented
+  const n = V.earningsLines(stateOf(), { ok: false, error: 'neither answered' }, 0.05, 28, T5);
+  assert.equal(n.day.text, 'IGN a day: reading the network');
+  assert.equal(n.day.sub, 'neither answered');
+  assert.equal(n.price.text, 'at £0.05 per IGN');
+  assert.equal(n.perKwh, null);
+  assert.equal(V.cardIgnDay(card({ hash_now: 25 }), chainOf()), '1,728');
+  assert.equal(V.cardIgnDay(card({ hash_now: 25 }), null), '');
+  assert.equal(V.fmtIgn(0.5), '0.5000 IGN'); assert.equal(V.fmtIgn(4.88044084), '4.88 IGN'); assert.equal(V.fmtIgn(207360), '207,360 IGN');
+});
+
+test('the block card on the four thresholds and on a new card; the first-hour timeline; the profile words', () => {
+  const s = stateOf(), c = chainOf({ mine: [key({ blocks: 100, voter: true, rank: 2 })], best: key({ blocks: 100, voter: true, rank: 2 }) });
+  const m = (kind, count, over) => ({ kind, count, card: 'nvidia:0:RTX 4070', card_name: 'NVIDIA GeForce RTX 4070', hash: 'ab'.repeat(32), daa: 1284117, at: T5 - 10, ...over });
+  assert.equal(V.blockCard(m('hundred', 100), s, c, T5).eyebrow, 'block 100 of this machine');
+  assert.equal(V.blockCard(m('thousand', 1000), s, c, T5).eyebrow, 'block 1,000 of this machine');
+  assert.equal(V.blockCard(m('ten_thousand', 20000), s, c, T5).eyebrow, 'block 20,000 of this machine');
+  assert.equal(V.blockCard(m('card', 7), s, c, T5).eyebrow, 'first block on NVIDIA GeForce RTX 4070');
+  assert.equal(V.blockCard(m('first', 1, { hash: '', daa: 0 }), s, c, T5).title, 'A block is yours.');
+  assert.equal(V.blockCard(m('first', 1, { hash: '', daa: 0 }), s, c, T5).url, '');
+  assert.equal(V.blockCard(m('first', 1), s, chainOf({ network: { ...chainOf().network, ramp_factor: 0.19, miner_ign_per_block: 4.88044084 } }), T5).ignLine, '4.88 IGN to 0xdd44…86E8 (72 producer points, 8 for signing, ramp 19%)');
+  assert.equal(V.blockCard(m('first', 1), s, c, T5).key, 'card:1:' + (T5 - 10));
+  const t = V.timeline(stateOf({ ladder: { ...stateOf().ladder, first_synced_at: T5 - 2800, first_mining_at: T5 - 2700, first_block_at: T5 - 2400 } }), T5);
+  assert.deepEqual(t.steps.map((x) => x.id), ['install', 'started', 'synced', 'mining', 'block', 'payout']);
+  assert.deepEqual(t.steps.map((x) => x.rel), ['+0 s', '+20 min', '+3 min', '+5 min', '+10 min', '+10 min']);
+  assert.match(t.steps[5].note, /coinbase of the first block/);
+  const u = V.timeline(stateOf({ installed_at: 0, uptime_s: 100 }), T5);
+  assert.equal(u.steps[0].note, 'not recorded on this install');
+  assert.equal(u.steps[2].note, 'the moment is not recorded; synced now');
+  assert.match(V.profileWords(true), /^Your address page on igneum\.network is public/);
+  assert.match(V.profileWords(false), /unlisted/);
+  assert.equal(V.gapWords(45), '45 seconds'); assert.equal(V.spanWords(3700), '1 h 1 min'); assert.equal(V.spanWords(3 * 86400), '3 days');
+  // the Activity lines for the milestones
+  assert.equal(V.plainEvent('first block: found by NVIDIA GeForce RTX 4070 (block card)').text, 'Your first block, found by NVIDIA GeForce RTX 4070');
+  assert.equal(V.plainEvent('block 1,000 of this machine: found by RTX 4070 (block card)').text, 'Block 1,000 of this machine, found by RTX 4070');
+  assert.equal(V.plainEvent('first block on Apple M5 Max (block card)').text, 'First block on Apple M5 Max');
+});

app/mac/IgneumMiner.swift

@@ -209,6 +209,9 @@ final class App: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKUIDele
                 }
             } else if line.hasPrefix("STATE ") {
                 applyState(String(line.dropFirst(6)))
+            } else if line.hasPrefix("SHOT ") {
+                // Miner UI 4 (b): the engine's POST /api/shot asks for a PNG of what the window shows, at this path
+                shotTo(String(line.dropFirst(5)).trimmingCharacters(in: .whitespaces))
             } else if line.hasPrefix("FATAL ") {
                 fail(String(line.dropFirst(6)))
             } else if line == "EXIT" {
@@ -322,6 +325,19 @@ final class App: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKUIDele
         let a = NSAlert(); a.messageText = "Igneum Miner"; a.informativeText = message; a.runModal(); completionHandler()
     }
 
+    // ---- a screenshot on request (the SHOT line), the app keeps running ----
+    func shotTo(_ path: String) {
+        let conf = WKSnapshotConfiguration()
+        conf.rect = web.bounds
+        web.takeSnapshot(with: conf) { image, error in
+            guard let img = image, let tiff = img.tiffRepresentation, let rep = NSBitmapImageRep(data: tiff), let png = rep.representation(using: .png, properties: [:]) else {
+                FileHandle.standardError.write("shot failed: \(error?.localizedDescription ?? "no image")\n".data(using: .utf8)!)
+                return
+            }
+            do { try png.write(to: URL(fileURLWithPath: path)) } catch { FileHandle.standardError.write("shot: could not write \(path): \(error)\n".data(using: .utf8)!) }
+        }
+    }
+
     // ---- snapshot ----
     func snapshot(to path: String) {
         if let js = ProcessInfo.processInfo.environment["IGNEUM_PROBE"] {

app/windows/host.cpp

@@ -16,6 +16,7 @@
 #endif
 #include <windows.h>
 #include <shellapi.h>
+#include <shlwapi.h>
 #include <dbt.h>
 #include <wrl.h>
 #include <string>
@@ -39,6 +40,13 @@ static HWND g_hwnd = nullptr;
 static HANDLE g_engine = nullptr, g_engineIn = nullptr, g_engineOut = nullptr;
 static ComPtr<ICoreWebView2Controller> g_controller;
 static ComPtr<ICoreWebView2> g_webview;
+// a PNG of the web view at `path` (the SHOT line); the stream is released by the completion handler
+static void capturePreview(const std::wstring& path) {
+    if (!g_webview) return;
+    ComPtr<IStream> stream;
+    if (FAILED(SHCreateStreamOnFileEx(path.c_str(), STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE, FILE_ATTRIBUTE_NORMAL, TRUE, nullptr, &stream))) return;
+    g_webview->CapturePreview(COREWEBVIEW2_CAPTURE_PREVIEW_IMAGE_FORMAT_PNG, stream.Get(), Callback<ICoreWebView2CapturePreviewCompletedHandler>([stream](HRESULT) -> HRESULT { return S_OK; }).Get());
+}
 static std::wstring g_url, g_status = L"starting the engine";
 static bool g_paused = false, g_quitting = false, g_exited = false, g_webviewOk = false, g_hintShown = false;
 static NOTIFYICONDATAW g_nid = {};
@@ -308,6 +316,9 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
             applyState(line->substr(6));
         } else if (line->rfind("ELEVATE ", 0) == 0) {
             runElevated(widen(line->substr(8)));
+        } else if (line->rfind("SHOT ", 0) == 0) {
+            // Miner UI 4 (b): the engine's POST /api/shot asks for a PNG of what the window shows, at this path
+            capturePreview(widen(line->substr(5)));
         } else if (line->rfind("FATAL ", 0) == 0) {
             g_status = widen(line->substr(6));
             repaintStatus();

app/windows/version.h

@@ -3,6 +3,6 @@
 // packaging/windows/Igneum-Miner.iss when the app version moves. Include guards, not #pragma once: rc.exe reads it too.
 #ifndef IGNEUM_HOST_VERSION_H
 #define IGNEUM_HOST_VERSION_H
-#define IGNEUM_HOST_VERSION_STR "0.3.14"
-#define IGNEUM_HOST_VERSION_RC  0,3,14,0
+#define IGNEUM_HOST_VERSION_STR "0.3.16"
+#define IGNEUM_HOST_VERSION_RC  0,3,16,0
 #endif

docs/bench-log.md

@@ -2544,6 +2544,35 @@ task now runs ...Programs\Igneum Miner\igneum-app.exe --power-helper"), then the
 task with no prompt ("-pl 460: set to 460.00 W from 575.00 W", "-pl 160: set to 160.00 W from 100.00 W"). Task
 Running, Highest, user Admin. Cards: 5090 221 W at 1845 MHz, 4070 75.8 W at 1860 MHz, 9070 XT 202 W, all mining
 through the installed app. Ember closed 16:53Z.
+### 6 October 2026, 17:55Z to 17:57Z, the first segment above the restart cut from a snapshot-restored node on the new export (Mac)
+
+A copy of node 1's data dir started on the shipper's 0.3.14 Mac binary (target-0314, release-0.3.14-node 4c6b129d) with
+`--igneum-exec-snapshot=node1-copy-snapshot.bin,0xac101f13...` (the hands' recovery file, tip 130,272) and node 1 as its
+peer: IBD of 8,049 blocks in 29 s, the executor resumed from the file and reached the tip 140,023 with no restart replay.
+`igneum_exportSegments [139951, 139959]` answered in under 0.1 s with 9 segments, `preState` 79 accounts, `execRestart`
+27,276. The branch exporter (exec-app-0314 bfebff1) cut all 8 blocks of segment 139,952..139,959 in under 0.1 s each:
+"replayed 8 segments from the account dump; every state root equals the node's". The first block's fixture carries
+pre-state root 0x64304441... and post-state root 0x60d60bba..., equal to node 1's eth_getBlockByNumber roots at 139,951
+and 139,952 (an independent node). Consequence: a prover on a snapshot-restored node (every hand, nine fleet boxes) cuts a
+provable fixture again with the 0.3.14 app and exporter; what is left for a paid record is the proof itself (the PCs or
+the fleet, not this Mac).
+
+### 6 October 2026, 18:11Z to 18:13Z, the PC shape over p2p (Mac, `tools/lock/with-lock.sh run`)
+
+Fork 1255c0f9. `node tools/exec-sync/net.mjs`: 18/18 in 117.5 s. Case 7: a node whose data dir holds the tip-0 pair the 0.3.13
+genesis replay left behind, with `--igneum-exec-snapshot=peer`, sets the pair aside (.bin.tip0), asks A over p2p and loads
+A's state with no hand action; its state root at 60 equals A's. `reorg.mjs` 18/18 in 262.1 s on the same binary; the exec
+suite 20. Consequence: a PC or a box left with the tip-0 pair recovers on its own once a hand serves (the 5-minute
+no-progress rule fires the ask even when the error text is new); until 0.3.14.1 the recovery file by hand is the way.
+
+## 6 October 2026, 18:18Z: the shipped 0.3.14 app asked to tune itself on PC 1 (ember-installed-pc1-1): FAILED, no tune ran
+
+Gate ok (0.3.14, Power control on, the task on the installed exe). Every card's "after" was its 17:55Z failure from
+the app's own first tune: 5090 and 4070 "did not take within 30 s (card reports 460 / 160 W, acknowledged true)",
+9070 XT "the card refused the setting"; the three "Tune now" requests sat queued behind the hour's back-off. Five
+causes (A to E) and their fixes in the plan's 0.3.14 window section; the window repeats on 0.3.15. The cards kept
+mining at the driver's held locks: 5090 222.9 W at 1845 MHz, 4070 75.9 W at 1860 MHz, 9070 XT 201 W. Lever-2 TUNING
+records during the window: 5090 135.6 MH/s at 236 W (0.574 MH/W), 4070 31.1 MH/s at 79 W (0.393).
 
 ## Prover tiers on real cards: the rented fleet, 6 October 2026 (branch gpu-fleet)
 

docs/community/discord/ladder.md

@@ -0,0 +1,78 @@
+# Discord: the ladder's rung announcements (message shapes, not posted)
+
+7 October 2026, miner-ui-5 (mission item 6, docs/analysis/mission/mission.md 2.6). The shapes the bot would post for
+each rung of the miner's ladder, so the words in Discord match the app and the site rung for rung. Nothing here is
+posted by this lane; the Discord lane wires them into `tools/community/discord-hooks.mjs` behind its guard rails
+(docs/community/discord-hooks.md: the forbidden-string guard, the limits, idempotency keys, never a mention). Every
+number is a chain fact from the public API (`/api/live`, `/api/stats`), which is the observer's copy of the node's
+`getFinalityWeights` and `getFinalityCheckpoints`; a post names nothing the chain does not say.
+
+## The rules every rung post obeys
+
+| Rule | How |
+|---|---|
+| The miner's object, never the project's | a post carries the key id, the block link, the rank and the day; never the network hashrate, the block count or a milestone of the project |
+| A chain fact only | the trigger is a field of `getFinalityWeights` (`keys[].blocks`, `keys[].voter`, `keys[].participation`, `voters`) or `getFinalityCheckpoints` (`latestLockedIndex`), read through `/api/live finality.weights` |
+| Opt-in for anything beyond the key id | the card model and the "(you)" link to the address page appear only when the miner switched "Make my page public" on in the app (settings.profile_public); without it the post is the key id and the block link |
+| Short key id | the first 8 hex of the vote key hash, the same id the app, `/live` and the explorer show; never a payout address, never a machine name |
+| One post per key per rung | idempotency key `rung:<rung>:<keyid>`; a rung is posted once for a key, ever (a key that drops and climbs back is not posted again) |
+| Copy law | no em dashes, no two-beat antithesis, no aphorisms; the numbers in the line, nothing decorative |
+| Volume | #first-blocks takes rungs 0 and 1 (one line each); #numbers takes the daily ladder summary; rungs 2 to 5 and P are never posted singly (one a minute at scale), they are counted in the summary |
+
+## Channel: #first-blocks
+
+### Rung 0, first block (trigger: a key's first blue block in the window; `keys[].blocks` goes 0 to 1 in `finality.weights`, and the block's `miner` is that key in `/api/live blocks[]`)
+
+```
+First block: key 6ad0e117
+Block 1,284,117 · igneum.network/block/9f3a…c21e
+RTX 4070 (the miner chose to show the card)
+```
+
+Without the opt-in the third line is absent. Embed: ember accent, title "First block", one field "Key" = `6ad0e117`, one field "Block" = the explorer link; footer the UK time with UTC in brackets (the hooks script's footer rule).
+
+### Rung 1, the vote (trigger: `keys[].voter` goes false to true, that is `blocks` reaches `params.dust`)
+
+```
+Your key has a vote: 6ad0e117
+100 blocks in the window (the line is 100) · the key now signs every checkpoint
+```
+
+On the devnet the line reads `5 blocks in the window (the line is 5)`: the number is `params.dust`, never a constant.
+
+## Channel: #numbers, the daily ladder summary (09:00 UK, beside the daily digest)
+
+```
+The ladder, yesterday
+First blocks: 14 keys found their first block
+Votes: 9 keys crossed the dust line (now 1,213 voters)
+Signatures: 1,201 keys signed a locked checkpoint (latest lock 184,220)
+Full window: 406 keys at 30 of 30 days
+Rank 1 by weight: 6e80f3ef with 2,592 blocks in the window
+Signing streak, longest: 41 days unbroken (presence 100%)
+Shards: 388 paid to 57 keys
+```
+
+Fields and sources, one per line:
+
+| Line | Field |
+|---|---|
+| First blocks | keys whose `blocks` went from 0 to at least 1 between the two daily reads of `finality.weights.keys[]` |
+| Votes | keys whose `voter` went false to true; `voters` for the total |
+| Signatures | keys with `participation` above 0 at the day's last read; `latest_locked_index` for the lock |
+| Full window | keys whose `blocks` span the whole `params.weightWindow` (owed from the node: `keys[].daysMined`; until then the line is left out, never estimated) |
+| Rank 1 | `keys[]` sorted by `blocks`, the top row |
+| Signing streak | owed from the node (`keys[].streakDays`); until then the line is left out |
+| Shards | `/api/live proving.shards_paid_10m` summed over the day's reads, provers from `live_proofs.prover` |
+
+A line whose field the node does not expose yet is left out of the post rather than estimated (the "no number a company server has to be trusted for" rule, reinvent.md section 6).
+
+## Roles (the Discord lane, from the same fields)
+
+| Role | Granted when | Revoked when |
+|---|---|---|
+| Voter | a message signed with the vote key names a key whose `voter` is true in `getFinalityWeights` | `voter` false at a daily read (a key under dust, or stripped: `strippedUntilDaa` above the DAA score) |
+| Window | the key's blocks span the full `params.weightWindow` (`keys[].daysMined` owed; until then by hand from the ladder summary) | the key misses a day |
+| Prover | a paid shard record names the key (`igneum_getProofRecords(block).paid[shard]`) | never (a paid record is a chain fact) |
+
+The signed message is the proof of key ownership; the app does not sign it yet (owed: a "prove my key" button that signs a nonce with the vote key and copies it).

docs/plans/ember-tune.md

@@ -296,8 +296,38 @@ record. Known in 0.3.13 on PC 1 until 0.3.14: the rows show the app's own earlie
 to receive the run's result), and the 80% caps are the app's setting; the draw is the tuned one regardless because
 the driver holds the clock locks and the caps do not bind.
 
+### The 0.3.14 window (6 October 2026, 18:18 to 18:27Z): no tune ran; five causes
+
+The shipped 0.3.14 app, Power control on, the task registered, asked over its own API to tune each card
+(`relay/playbooks/ember-installed-tune-pc1.ps1`). From its log and helper.log:
+
+| | When (UTC) | What | Cause | Fix (0.3.15) |
+|---|---|---|---|---|
+| C | 17:55:25 | the app's own first 5090 tune wrote its first request in the second the helper started; the helper skipped it as "present at my start"; 30 s later "did not take (card reports 460 W, acknowledged true)" | the engine wrote before the helper was up | the helper writes a heartbeat (`helper.alive`) every poll; the engine starts the task and waits for a fresh heartbeat BEFORE writing (`powertask::ensure_running`) |
+| A | 17:55:55 | the 4070's helper start read the stale `quit` from the 5090's abort and exited in the same second | quit/remove matched before the sequence check | the helper acts only on lines added after its start (`commands_after`) |
+| D | 17:57:27 | the 9070 XT, measure only ("igneum-gpu-telemetry gave no tune line": the 3.0 coordinator's job was on the ADLX helper), was still sent a set; refused; "tuning stopped" | a measure-only card was set | `ember::may_set`: measure only sets nothing |
+| E | 18:18 to 18:27 | three "Tune now" requests sat "queued" behind the hour's back-off from the 17:55 failures; none started | `sweep_retry` blocked a forced request silently | a forced request clears the back-off; a held row says "tuning: retry in N min (why)" (`ember::retry_note`) |
+| B | (latent) | the engine's helper flag stayed true after the helper's idle exit; a later step would have been acknowledged after a blind 4 s sleep | a flag instead of a fact | the heartbeat decides; the acknowledgement is the helper's own log line for the sequence (up to 15 s), a missing line fails the step with that reason |
+
+What a user on 0.3.14 sees: Power control on, no prompt, and no card tunes (the rows keep the baseline or
+"tuning stopped"); the lever-2 TUNING records still flow. 0.3.15 closes it; the window repeats there.
+
 ## 8a. Next-cut notes (for the 0.3.12 shipper)
 
+For 0.3.16 (Miner UI 4's Cards tab, Ember as its second layer), on ember-tune past the 0.3.15 tip 7fadd4c:
+
+| Commit | What | Where |
+|---|---|---|
+| (past 7fadd4c) | a per-card goal: `POST /api/tune/goal {key, goal}` (efficiency, balanced, rate; "" or "global" clears), persisted as `CardPref.tune_goal`, echoed as `card.tune_goal` ("" = the global goal), resolved at the tune's start (`ember::goal_for`); the untuned point of the last full plan on the row: `card.tune_before_watts`, `card.tune_before_mhs` (its step 0, kept across confirm plans; `CardPref.sweep_before_*`), so the row can read "saves 84 W, 0.15% of rate" against `sweep_watts` / `sweep_mhs`; Retune = `POST /api/sweep/start {key}` (forced: clears a back-off since 0.3.15) | ember.rs, engine.rs, server.rs, config.rs, state.rs, hotplug.rs + test |
+
+For the 0.3.15 cut (6 October 2026 evening), on ember-tune:
+
+| Commit | What | Where |
+|---|---|---|
+| a8cab23 | (A) the helper acts only on lines added after its start; the acknowledgement is the helper's log line for the sequence | powertask.rs `commands_after` + test, engine.rs |
+| (tip) | (B, C) the heartbeat, `ensure_running` before every task-path write; (D) `may_set`; (E) the back-off yields to a forced request, `retry_note`; the window playbook's gate at 0.3.15; `ember-tune-pc1.ps1` deleted (superseded by the installed-tune playbook) | powertask.rs, engine.rs, ember.rs + tests, relay/playbooks |
+| e70ac5e | every task command goes to the helper's fixed folder | platform.rs, powertask.rs, engine.rs, main.rs + test |
+
 For the 0.3.14 cut (6 October 2026, after run 6), on ember-tune:
 
 | Commit | What | Where |

docs/plans/miner-ui-3.md

@@ -275,3 +275,35 @@ the quit ask, paused, syncing, the clock, the update card, the job strip, the lo
 | A Windows and a PC screenshot of the row with a real NVIDIA card (the telemetry cells, the cap slider, Retry) | the 0.3.14 cut, first thing to look at |
 | The row's state word while tuning carries the meta after it ("tuning: step 7 of 9 · measuring 441 W · 32 GB · ...") and is cut on a narrow row | a later pass: drop the meta while tuning |
 | The merge with `ember-tune`: `app.js` takes this branch's file (it already carries ember-tune's UI words and test); the engine files merge by themselves | the 0.3.14 shipper |
+
+## 14. Polish round (6 October 2026, after the 0.3.14 cut)
+
+the project lead, on the live Mac app: "I do think this could look better", at the job strip reading "Job: 0.3.14 is published:
+re-read the manifest and install now (...) done after 0 min. Report uploaded." Branch rebased on master 630b537.
+
+| What | Where |
+|---|---|
+| No raw job, manifest or relay text on a user surface. The strip reads "A job from the team ran: update check, 0 min." / "A job from the team is running: shard benchmark, 6 min. Proving shard 3 of 8." / "A job from the team failed: build, after 32 min." / "Updated to 0.3.14 at 18:52."; the technical line (the job's title, summary, RESULT line, exit code) sits behind a chevron; the × stays. `Notices.jobWord` maps a kind or an id prefix to a user's word (update check, restart, log collection, shard benchmark, build, tuning check, a script). | app.js Notices |
+| The Activity feed speaks in the app's voice: `View.plainEvent` maps every engine event string (`src/engine.rs` et al., 80 patterns) to a sentence ("Block found by Apple M5 Max", "Rule settings read from the team", "The node stopped (code 101); restarting", "A job from the team ran: update check, 0 min"); the engine's own line is the row's tooltip; the kind word becomes a coloured dot. Unknown lines keep their words with a JSON tail cut. | app.js View, renderMine |
+| The header: title, grey subtitle and the pill share one baseline; the pill is a sentence with a coloured dot: "Mining · 511 MH/s" (molten), "Tuning" (molten), "Paused", "Syncing the node", "Starting the worker", "Not mining" (grey), "Node restarting", "Node failed", "Engine not answering" (ember), "Stopping", "Detecting cards", "Setting up". `View.pill`. | app.js, app.css |
+| Three Mine layouts were offered behind `?variant=a|b|c` (quieter, denser, hero number); the project lead picked C, then ruled the page stays as shipped (section 15). The switch is gone. | app.css |
+| 390 px: the strip's text, chevron and × on one line. Light and dark checked. | app.css |
+
+Screenshots: `p04`/`p05` the plain job strip closed and open, `p06` the updated strip,
+`p07` the header paused, `p08` the activity feed, `p09`/`p12` light, `p10`/`p11` 390 px. Tests: 36 pass.
+
+## 15. the project lead's ruling: the banner only (6 October 2026, evening)
+
+the project lead: "lets not actually change the miner page just sort the banner". Variant C and the Earnings reshaping are
+reverted; the Mine and Earnings screens are exactly as shipped in 0.3.14. The three variant screenshots are gone with
+them. What stays from the polish round:
+
+| Kept | Where |
+|---|---|
+| The strip's look: the row surface (one step lighter than the page), a 1 px ember hairline along the top, ash text, ember only on the state dot and the chevron; the update strip and the job strip share the one `.notice`; the asks and the clock card carry the same hairline. No filled brown or mustard field anywhere (the rail's active item, the pill, the ghost-on button, the option, the stop ring, the log hit and `mark` lost their tints; only `::selection` keeps a colour). | app.css |
+| The strip's words: "A job from the team ran: update check, 0 min." / "Updated to 0.3.14 at 18:52.", the technical line behind the chevron, the × kept | app.js Notices |
+| The Activity feed in the app's voice (`View.plainEvent`, the engine line as the tooltip, a kind dot) | app.js View, renderMine |
+| The header: title, subtitle and pill on one baseline; the pill a sentence with a coloured dot (`View.pill`) | app.js, app.css |
+
+Screenshots: `r01-mine-strip-dark.png`, `r02-mine-strip-light.png` (Mine as shipped, the job strip showing),
+`r03-earnings-dark.png`. Tests: 36 pass.

docs/plans/miner-ui-4-copy.md

@@ -0,0 +1,190 @@
+# Igneum Miner UI 4: the copy sweep (6 October 2026, 20:0x UK)
+
+the project lead, on the Cards screenshot: "'As the fleet' might need some work, check all UI copy for simplicity." Every string in
+`index.html` and `app.js` was read against the rules: no word a home miner would not use (fleet, lane, identities,
+prior, hill climb, sweep, DAA, epoch, vote key, digest, manifest, shard, segment, aggregator, verifier, worker, engine
+become plain words or carry one grey explanation), every state line one short sentence with the number first, labels
+are nouns and buttons are verbs, no colon where a sentence will do, no two-beat lines, one word for one thing (tune,
+card). Main's correction (20:0x UK): the chain's own objects keep the words of the site, the litepaper and the ledger,
+with a grey explanation where they first appear: shard (not piece), segment (not run of blocks), checkpoint and
+"locked checkpoint" (not lock point), aggregator (not combiner), verifying (not checking proofs); "network blocks (the
+DAA score)" stays. The rows below that renamed those words are superseded by this correction. the project lead's rulings folded in: the per-card inherit option is "Default · <shared goal>" in grey, updating when the
+shared goal changes; "Default" wherever a per-card setting follows the shared one (the cap's "Back to Default"); the
+Cards strip is titled "Ember Tune"; every goal option carries its meaning as a tooltip: Efficiency "most hashes per
+watt, a little rate traded", Balanced "a little rate for most of the saving", Maximum "most hashes, watts second",
+Default "the goal set for all cards". 150 strings changed.
+
+## The ten most visible
+
+| Where | Old | New |
+|---|---|---|
+| Cards, the per-card goal | As the fleet | Default · Balanced (grey, follows the shared goal) |
+| Cards, the strip | (no title) | Ember Tune, with each goal's meaning on hover |
+| Cards, the Ember line from a prior | Tuned 2 min ago from the fleet prior | Tuned 2 min ago from what other miners found |
+| Cards, the details label | Identities | Miners on this card |
+| Cards, the cap lines | cap applied: 460 W / cap not applied: Windows needs the administrator prompt / Unpin | Cap in force: 460 W / Cap not set yet. Windows needs the administrator prompt. / Back to Default |
+| Cards, the row's state word | held for a remote job / stopped after repeated faults | paused for a job from the team / stopped after repeated errors |
+| Overview, the big button | switch a GPU on below first / no GPU this app can drive / worker starting | switch a card on in Cards first / no card this app can use / card starting |
+| Prove | off: relay only / Every block is turned into a short proof. The chain hands pieces to your cards | off, passing proofs along / Every block is turned into a short proof, in pieces called shards. Your cards prove shards and earn IGN for each one (shard, segment and aggregator keep their names, each explained once) |
+| Node details | DAA score / rules digest / next rule switch / last lock | network blocks (the DAA score) / rules fingerprint / next rule change / last checkpoint (a point the miners agree can never be undone) |
+| Settings | Vote on finality checkpoints / Trust proof records without verifying them / Hill climb | Vote on checkpoints / Trust proofs without checking them / Fine tuning |
+
+Every toast and event sentence lost its semicolon or colon joint for a full stop ("Mining stops. The node keeps
+running"). "Worker" (the engine's word for a card's mining process) became "card" wherever a user reads it; "engine"
+became "app"; "fleet prior" became "what other miners found". Shard, segment, checkpoint and aggregator stay (the
+chain's own words), each with a grey explanation where it first appears. The engine's own log strings are untouched: `View.plainEvent` maps them.
+
+## Every string changed
+
+| File | Where | Old | New |
+|---|---|---|---|
+| index.html | The chain scene canvas label | The last two minutes of blocks: this machine's lane and the others, the selected chain as a lit path, checkpoints as bands | The last two minutes of blocks: your row and the other miners, the main chain as a lit path, locks as bands |
+| index.html | Node details: DAA score row | <span class="k">DAA score</span><span class="v mono" id="n-daa">0</span><span class="m">blocks the whole network has made</span> | <span class="k">network blocks</span><span class="v mono" id="n-daa">0</span><span class="m">blocks the whole network has made (the DAA score)</span> |
+| index.html | Node details: votes row | this machine signs a checkpoint every 30 s | this machine signs a lock point every 30 s |
+| index.html | Node details: digest label | <div class="k">rules digest</div> | <div class="k">rules fingerprint</div> |
+| index.html | Node details: tips row | open ends of the block DAG right now | open ends of the chain right now |
+| index.html | Node details: blue score row | blocks on the agreed main chain</span> | blocks on the agreed main chain (the blue score)</span> |
+| index.html | Node details: next switch label | <div class="k">next rule switch</div> | <div class="k">next rule change</div> |
+| index.html | Prove: segments row | whole segments this machine proved | whole runs of blocks this machine proved |
+| index.html | Prove: shard program id label | <div class="k">shard program id</div> | <div class="k">proof program id</div> |
+| index.html | Prove: aggregator id label | <div class="k">aggregator id</div> | <div class="k">combiner program id</div> |
+| index.html | Prove: lead sentence | Every block is turned into a short proof. The chain hands pieces to your cards; each piece proven pays IGN. | Every block is turned into a short proof. Your cards prove pieces of it and earn IGN for each one. |
+| index.html | Settings: Ember Tune switch | Tunes every card for hashes per watt: once after install, then every 7 days, and after a driver or program change. | Tunes every card for the most hashes per watt. Once after install, then every 7 days, and after a driver or program change. |
+| index.html | Settings: Hill climb switch | <b>Hill climb</b> <span class="dim">Searches around the best point instead of walking the ladders.</span> | <b>Fine tuning</b> <span class="dim">Searches around the best point instead of stepping down a ladder.</span> |
+| index.html | Settings: vote switch | <b>Vote on finality checkpoints</b> <span class="dim">Signs a checkpoint every 30 s. Votes lock the chain; leave it on.</span> | <b>Vote on lock points</b> <span class="dim">Signs a lock point every 30 s. Votes are what lock the chain. Leave it on.</span> |
+| index.html | Settings: trust switch | <b>Trust proof records without verifying them</b> <span class="dim">Devnet only. Without a verifier the node includes records it never checked. Changing this restarts the | <b>Trust proofs without checking them</b> <span class="dim">Devnet only. The node includes proofs it never checked. Changing this restarts the node.</span> |
+| index.html | Settings: remote jobs switch | Signed jobs (a benchmark, a script, logs to collect) run here once and report back. | Signed jobs from the team (a benchmark, a script, logs to collect) run here once and report back. |
+| index.html | Settings: Power control | Off, NVIDIA cards are measured only. | Off, NVIDIA cards are only measured. |
+| index.html | Earnings: dev fee switch | Dev fee: 1 block in 100 pays the miner software's author | Dev fee: 1 block in 100 pays the people who make this app |
+| index.html | Setup: address lead | Paste an Ethereum-style address you control: 0x and 40 characters. | Paste an address you control. It starts with 0x and has 40 characters after it. |
+| index.html | Setup: GPU note | An integrated GPU is off by default: it is slow and shares the machine's memory. | A built-in GPU starts off. It is slow and shares the machine's memory. |
+| index.html | Settings: price | pence per kWh. Every £ figure uses it. | pence per kWh. Every £ figure uses this. |
+| index.html | Settings: name help | A label for you only. | A name for you only. |
+| index.html | Prove: setup note | About 20 minutes, once. | Takes about 20 minutes, once. |
+| index.html | Cards: the strip title |       <div class="card tune-strip" id="tune-card">         <div class="ts-row"> |       <div class="card tune-strip" id="tune-card">         <div class="card-head"><h3>Ember Tune</h3><span class="eyebrow">tunes every card for hashes per watt</span></di |
+| index.html | Cards: the shared goal options with their meanings |             <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false">Efficiency</button>             <button class="seg-b" data-goal="balanced" role |             <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false" title="most hashes per watt, a little rate traded">Efficiency</button>          |
+| index.html | Settings: the shared goal options with their meanings |             <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false">Efficiency</button>             <button class="seg-b" data-goal="balanced" role |             <button class="seg-b" data-goal="efficiency" role="radio" aria-checked="false" title="most hashes per watt, a little rate traded">Efficiency</button>          |
+| app.js | Cards: the per-card goal options | [['', 'As the fleet'], ['efficiency', 'Efficiency'], ['balanced', 'Balanced'], ['rate', 'Maximum']].map(function (o) { return '<button class="seg-b' + (g === o[0] ? ' on' | [['', 'Default', 'the goal set for all cards'], ['efficiency', 'Efficiency', 'most hashes per watt, a little rate traded'], ['balanced', 'Balanced', 'a little rate for mo |
+| app.js | Cards: the fleet saving line | ' over ' + n + ' tuned card' | ' across ' + n + ' tuned card' |
+| app.js | Cards: the Ember line from a prior | ' from the fleet prior' | ' from what other miners found' |
+| app.js | Cards: the Ember line, measured sub | 'Apple silicon sets its own clocks' | 'Apple silicon sets its own power' |
+| app.js | Cards: the tune line, prior | ' from the fleet prior, confirmed' | ' from what other miners found, confirmed' |
+| app.js | Cards: the schedule, off | 'Ember Tune is off. Tune and Tune all still work by hand.' | 'Ember Tune is off. Tune and Tune all still work when you press them.' |
+| app.js | Cards: the floor note | ' (the ladder’s floor)' | ' (the lowest clock Ember will set)' |
+| app.js | Cards: identities label | <span class="k">Identities</span><p class="help"> | <span class="k">Miners on this card</span><p class="help"> |
+| app.js | Cards: identities toast | 'Identities set; that card’s worker restarts' | 'Set. The card restarts' |
+| app.js | Cards: cap help, Ember may move it | 'Ember Tune may move it.' | 'Default: Ember may move it.' |
+| app.js | Cards: cap help, pinned | 'Set by hand, so the tune leaves it. <button class="btn tiny ghost" data-pin="0">Unpin</button>' | 'Set by hand, so Ember leaves it. <button class="btn tiny ghost" data-pin="0">Back to Default</button>' |
+| app.js | Cards: cap applied | '<div class="line ok">cap applied: <b>' + want + ' W</b>' | '<div class="line ok">Cap in force: <b>' + want + ' W</b>' |
+| app.js | Cards: cap not applied | '<div class="line hot">cap not applied: Windows needs the administrator prompt <button class="btn tiny" data-power-retry="1">Retry</button></div>' | '<div class="line hot">Cap not set yet. Windows needs the administrator prompt. <button class="btn tiny" data-power-retry="1">Retry</button></div>' |
+| app.js | Cards: chosen by the tune pin | ' <span class="pin">chosen by the tune</span>' | ' <span class="pin">Ember’s choice</span>' |
+| app.js | Cards: Apple cap help | '<p class="help">Apple silicon manages its own power; there is no cap to set.</p>' | '<p class="help">Apple silicon manages its own power. There is no cap to set.</p>' |
+| app.js | Cards: facts line worker | cd.worker ? 'worker ' + cd.worker : '' | cd.worker ? 'runs on ' + cd.worker : '' |
+| app.js | Row word: held | 'held for a remote job' | 'paused for a job from the team' |
+| app.js | Row word: faulted | 'stopped after repeated faults' | 'stopped after repeated errors' |
+| app.js | Big button: held | 'a remote job holds the cards; mining restarts when it ends' | 'a job from the team is using the cards. Mining restarts when it ends' |
+| app.js | Hero sub: no GPU worker | m.state === 'idle' ? 'no GPU worker' | m.state === 'idle' ? 'no card mining' |
+| app.js | Hero sub: worker starting | (n.synced ? 'worker starting' : 'waiting for the node') | (n.synced ? 'card starting' : 'waiting for the node') |
+| app.js | Big button: worker starting | sub: n && n.synced ? 'worker starting' : 'waiting for the node to sync' | sub: n && n.synced ? 'card starting' : 'waiting for the node to sync' |
+| app.js | Big button: switch a GPU on | 'switch a GPU on below first' | 'switch a card on in Cards first' |
+| app.js | Big button: no GPU | 'no GPU this app can drive' | 'no card this app can use' |
+| app.js | Strip fallback: mining | 'mining: a block this machine finds appears here' | 'Mining. A block this machine finds appears here' |
+| app.js | Strip fallback: paused | 'paused: no blocks while mining is stopped' | 'Paused. No blocks while mining is stopped' |
+| app.js | Strip fallback: worker | state.node.synced ? 'waiting for the worker' : 'waiting for the node to sync' | state.node.synced ? 'waiting for the card' : 'waiting for the node to sync' |
+| app.js | Chain scene: the note | 'The full chain view needs the next engine update; this is the last 10 minutes of your own blocks.' | 'The full chain view needs the next update. This is the last 10 minutes of your own blocks.' |
+| app.js | Chain scene: the state word | st === 'failed' ? 'your blocks' | st === 'failed' ? 'your blocks only' |
+| app.js | Node: next program sub | 'until the next hourly mining program' | 'until the next hourly program' |
+| app.js | Node: next program unknown | 'known once the node runs' | 'known once the node is running' |
+| app.js | Node: finality note | 'a point the miners agreed can never be undone; locks at 2/3 of the 30-day weight' | 'a point the miners agreed can never be undone. It locks at two thirds of the last 30 days of mining' |
+| app.js | Node: finality none | 'locks appear once the miner votes on checkpoints' | 'locks appear once this machine votes' |
+| app.js | Node: switch line | 'A switch is a planned rule change. The node applies it by itself when the chain reaches that height.' | 'A rule change is planned ahead. The node applies it by itself when the chain reaches that height.' |
+| app.js | Node: switch line, all behind | 'Every planned switch is behind this node. ' | 'Every planned rule change is behind this node. ' |
+| app.js | Node: switch line, at DAA | sw.name + ' at DAA ' + withCommas(sw.daa) + ': ' + blocks | sw.name + ' at block ' + withCommas(sw.daa) + ': ' + blocks |
+| app.js | Node: manifest switch line | 'The update manifest announces a switch at DAA ' + withCommas(n.consensus_switch_daa) | 'A rule change is announced at block ' + withCommas(n.consensus_switch_daa) |
+| app.js | Node: digest not printed | 'not printed yet' | 'not read yet' |
+| app.js | Prove: the words off | 'Off. Switch it on and this machine proves the pieces the chain assigns to its keys.' | 'Off. Switch it on and this machine proves the pieces it is given.' |
+| app.js | Prove: proving sub | sub: pv.current \|\| 'a shard' | sub: pv.current \|\| 'a piece' |
+| app.js | Prove: idle note | 'On. Nothing is assigned to your keys right now; the next shard arrives within a minute.' | 'On. Nothing to prove right now. The next piece arrives within a minute.' |
+| app.js | Prove: proving note | 'A proof takes minutes on a CPU and seconds on a CUDA card.' | 'A proof takes minutes on a CPU and seconds on an NVIDIA card.' |
+| app.js | Prove: tier, cannot prove yet | ': cannot prove yet (the prover is CUDA only).' | ': cannot prove yet (proving needs an NVIDIA card).' |
+| app.js | Prove: tier, proves while it mines | ': proves while it mines (' + gb + ' GB; a full shard needs ' + SHARD_GB + ' GB).' | ': proves while it mines (' + gb + ' GB; a full piece needs ' + SHARD_GB + ' GB).' |
+| app.js | Prove: tier, cannot prove a full shard | ': cannot prove a full shard (' + gb + ' GB; a full shard needs ' + SHARD_GB + ' GB).' | ': cannot prove a full piece (' + gb + ' GB; a full piece needs ' + SHARD_GB + ' GB).' |
+| app.js | Prove: toast on | 'Proving on; the first piece arrives within a minute' | 'Proving on. The first piece arrives within a minute' |
+| app.js | Prove: verifier words | { command: 'verifying', trust: 'trusting (devnet only)', off: 'off: relay only', unknown: 'not read yet' } | { command: 'checking proofs', trust: 'trusting without checking (devnet only)', off: 'off, passing proofs along', unknown: 'not read yet' } |
+| app.js | Prove: segments line | 'whole segments this machine proved' | 'whole runs of blocks this machine proved' |
+| app.js | Prove: segments held | ', ' + pv.segments_held + ' held for the chain rule' | ', ' + pv.segments_held + ' waiting for the chain' |
+| app.js | Prove: segments last | (pv.segment_last_s ? ', the last in ' | (pv.segment_last_s ? ', the last took ' |
+| app.js | Earnings: dev fee off | 'Dev fee off: every block pays your address' | 'Dev fee off. Every block pays your address' |
+| app.js | Earnings: dev fee on | 'Dev fee: 1 block in 100 pays the miner software’s author' | 'Dev fee: 1 block in 100 pays the people who make this app' |
+| app.js | Earnings: dev fee line | 'The protocol takes nothing; this is the miner software’s fee, the same way every GPU miner takes one' | 'The network itself takes nothing. This is the app’s fee, the same way every mining app takes one' |
+| app.js | Earnings: dev fee line off | 'The protocol takes nothing either.' | 'The network itself takes nothing either.' |
+| app.js | Earnings: key help | 'The key for this address was made on this machine and is stored in the app folder, readable by your user only. Keep a copy somewhere safe.' | 'The key for this address was made on this machine and is stored in the app folder. Only your user can read it. Keep a copy somewhere safe.' |
+| app.js | Settings: jobs note off | 'Off: nothing runs here until the switch above allows remote jobs.' | 'Off. Nothing runs here until the switch above allows jobs from the team.' |
+| app.js | Settings: jobs note no address | 'No jobs address in this build.' | 'This build has no jobs address.' |
+| app.js | Settings: jobs note running | 'Running ' + jobTitle(j) + ' (' + j.id + ').' | 'Running: ' + jobTitle(j) + '.' |
+| app.js | Settings: update note current | 'Up to date' + (u.checked_at ? ', checked ' + rel(state.now - u.checked_at) : '') + '.' | 'Up to date' + (u.checked_at ? '. Checked ' + rel(state.now - u.checked_at) : '') + '.' |
+| app.js | Settings: update note never | 'Not checked yet. The engine checks by itself every hour.' | 'Not checked yet. The app checks by itself every hour.' |
+| app.js | Settings: update note rule change | 'A rule switch comes at height ' + withCommas(u.activation_height) + '.' | 'A rule change comes at block ' + withCommas(u.activation_height) + '.' |
+| app.js | Settings: price toast | 'A price in pence per kWh, for example 28' | 'Type a price in pence per kWh, for example 28' |
+| app.js | Settings: Ember toast | 'Ember Tune on: once after install, then every 7 days' | 'Ember Tune on. Once after install, then every 7 days' |
+| app.js | Settings: Power control on toast | 'Power control on: Windows asks for administrator rights once' | 'Power control on. Windows asks for administrator rights once' |
+| app.js | Settings: Power control off toast | 'Power control off; nothing asks' | 'Power control off. Nothing asks' |
+| app.js | Settings: trust on toast | 'Trust mode on (devnet only); the node restarts' | 'Trust mode on (devnet only). The node restarts' |
+| app.js | Settings: trust off toast | 'Trust mode off; the node restarts' | 'Trust mode off. The node restarts' |
+| app.js | Settings: applied toasts | 'Applied; the miner restarts' | 'Applied. Mining restarts' |
+| app.js | Cards: switch on toast | 'Worker starting on that card' | 'Starting that card' |
+| app.js | Cards: switch off toast | 'Worker stopped on that card' | 'That card is off' |
+| app.js | Cards: cap toast | 'Power cap set; pinned until you unpin it' | 'Power cap set. It stays until you choose Default again' |
+| app.js | Cards: sendCards default toast | 'Applied; only the changed worker restarts' | 'Applied. Only that card restarts' |
+| app.js | Cards: stop toast | 'Tune stopped; the card is back where it was' | 'Tune stopped. The card is back where it was' |
+| app.js | Cards: pin toast | 'The tune chooses the cap again' | 'Default: Ember chooses the cap again' |
+| app.js | Cards: retry toast | 'Administrator prompt: allow it to set the cap' | 'Allow the administrator prompt to set the cap' |
+| app.js | Cards: Tune all toast | 'Tune queued for ' + n + ' cards, one at a time' | 'Tune queued for ' + n + ' cards, one after another' |
+| app.js | Overview: toggle toast | 'Mining stops; the node keeps running' | 'Mining stops. The node keeps running' |
+| app.js | Address ask | ' from the next block? The miner restarts.' | ' from the next block? Mining restarts.' |
+| app.js | Trust ask on | 'Include proof records the node never checked? Devnet only; the node restarts.' | 'Include proofs the node never checked? Devnet only. The node restarts.' |
+| app.js | Trust ask off | 'Verify proof records again? The node restarts.' | 'Check proofs again? The node restarts.' |
+| app.js | Pill: engine away | 'Engine not answering' | 'App not answering' |
+| app.js | Node line: engine away | 'the engine is not answering; the window reconnects by itself' | 'the app is not answering. The window reconnects by itself' |
+| app.js | Button: engine away | 'the engine is not answering' | 'the app is not answering' |
+| app.js | Hero: engine away | 'no answer from the engine' | 'no answer from the app' |
+| app.js | Toast: engine did not answer | 'The engine did not answer' | 'The app did not answer' |
+| app.js | Settings: goal toast | 'The goal needs the Ember Tune update' | 'The goal needs the next Ember Tune update' |
+| app.js | Cards: card goal toast | 'A per-card goal needs the Ember Tune update' | 'A goal for one card needs the next Ember Tune update' |
+| app.js | Cards: card goal set toast | 'This card follows the fleet goal' | 'Default: this card follows the goal set for all cards' |
+| app.js | Activity: identity events | m[1] + ': ' + m[2] + ' identit' + m[3] + '; its worker restarts' | m[1] + ': ' + m[2] + ' miner' + (m[2] === '1' ? '' : 's') + ' on it. The card restarts' |
+| app.js | Activity: worker ready | m[1] + ': worker ready' | m[1] + ': ready' |
+| app.js | Activity: worker fault | m[1] + ': worker fault; restarting it' | m[1] + ': an error. Restarting it' |
+| app.js | Activity: worker stopped | 'A worker stopped (code ' + m[2] + '); restarting in ' + m[3] + ' s' | 'A card stopped (code ' + m[2] + '). Restarting in ' + m[3] + ' s' |
+| app.js | Activity: worker built | 'Worker built' | 'Mining program built' |
+| app.js | Activity: program variant | m[1] + ': program variant chosen, ' + m[3] + ' MH/s' | m[1] + ': fastest program chosen, ' + m[3] + ' MH/s' |
+| app.js | Activity: segment proven pieces | 'Segment proven: ' + m[3] + ' pieces in ' + m[4] + ' s' | 'Run of blocks proven: ' + m[3] + ' pieces in ' + m[4] + ' s' |
+| app.js | Activity: segment proven | 'Segment proven in ' + m[3] + ' s' | 'Run of blocks proven in ' + m[3] + ' s' |
+| app.js | Activity: segment paid | 'Segment paid: ' + m[1] + ' IGN' | 'Run of blocks paid: ' + m[1] + ' IGN' |
+| app.js | Activity: segment held | 'Segment proven: ' + m[3] + ' pieces in ' + m[4] + ' s; its record waits for the chain rule' | 'Run of blocks proven: ' + m[3] + ' pieces in ' + m[4] + ' s. Its record waits for the chain' |
+| app.js | Activity: segment accepted | 'Segment record accepted' | 'Run of blocks accepted' |
+| app.js | Activity: node external | 'The team asked for a node restart; this node is not the app’s, so nothing was done' | 'The team asked for a node restart. This node is not the app’s, so nothing was done' |
+| app.js | Activity: no peer | 'No other node found after 90 s; still looking' | 'No other node found after 90 s. Still looking' |
+| app.js | Activity: node stopped restarting | 'The node stopped (code ' + m[1] + '); restarting' | 'The node stopped (code ' + m[1] + '). Restarting' |
+| app.js | Activity: no reading | 'No reading from the node for ' + m[1] + ' s; restarting it' | 'No reading from the node for ' + m[1] + ' s. Restarting it' |
+| app.js | Activity: mining paused | 'Mining paused; the node keeps running' | 'Mining paused. The node keeps running' |
+| app.js | Activity: settings changed | 'Settings changed (' + m[1] + '); mining restarts' | 'Settings changed (' + m[1] + '). Mining restarts' |
+| app.js | Activity: tune best point | m[1] + ': best point ' + m[2] + ' (' + m[3] + '); your cap stays pinned' | m[1] + ': best point ' + m[2] + ' (' + m[3] + '). Your cap stays pinned' |
+| app.js | Activity: next program compiles | m[1] + ': the next program compiles at the hour boundary instead' | m[1] + ': the next program is built at the top of the hour instead' |
+| app.js | Activity: new program worker | 'New hourly program; the worker restarts on it' | 'New hourly program. The card restarts on it' |
+| app.js | Activity: pack | 'Rebuilding the program pack' | 'Rebuilding the mining programs' |
+| app.js | Activity: trust | 'Devnet trust mode: proof records are not verified (Settings)' | 'Devnet trust mode: proofs are not checked (Settings)' |
+| app.js | Activity: sweep caps | 'A tune is setting the caps now; retry when it is done' | 'A tune is setting the caps now. Retry when it is done' |
+| app.js | Activity: updates off engine | 'Updates are off for this engine (a measurement run)' | 'Updates are off for this copy (a measurement run)' |
+| app.js | Activity: power cap not applied | 'Power cap not applied: the administrator prompt was refused (Retry on the card)' | 'Power cap not set. The administrator prompt was refused (Retry on the card)' |
+| app.js | Activity: node too old | 'This node is too old for the team’s rule settings; an app update carries the newer node' | 'This node is too old for the team’s rule settings. An app update carries the newer node' |
+| app.js | Row word: unplugged | 'unplugged; its worker stopped. The row goes in five minutes.' | 'unplugged. Its row goes in five minutes.' |
+| app.js | Details: removed | '<p class="help">The card was unplugged; its worker stopped. The row goes in five minutes.</p>' | '<p class="help">The card was unplugged. Its row goes in five minutes.</p>' |
+| app.js | Details: problem | 'No worker can drive this card.' | 'This app cannot use this card.' |
+| app.js | Setup: no cards | 'No graphics card this app can drive was found.' | 'No graphics card this app can use was found.' |
+| app.js | Overview: no cards | 'No graphics card this app can drive was found. The node runs on its own.' | 'No graphics card this app can use was found. The node runs on its own.' |
+| app.js | Pages: overview sub | sub: 'the rate, what it costs, the chain as it grows' | sub: 'your rate, what it costs, the chain as it grows' |
+| app.js | Pages: prove sub | sub: 'turn blocks into proofs, paid in IGN' | sub: 'prove blocks, earn IGN' |
+| app.js | Pages: earnings sub | sub: 'what it made, where it goes' | sub: 'what you made, where it goes' |
+| app.js | Goal names for the Default option |   var GOALS = { efficiency: 'the most hashes per watt', balanced: 'hashes per watt within 1% of the top rate', rate: 'the top rate, whatever the watts' }; |   var GOALS = { efficiency: 'the most hashes per watt', balanced: 'hashes per watt within 1% of the top rate', rate: 'the top rate, whatever the watts' };   var GOAL_NAME |
+| app.js | Export GOAL_NAMES | GOALS: GOALS, goalWords: goalWords, | GOALS: GOALS, GOAL_NAMES: GOAL_NAMES, goalWords: goalWords, |

docs/plans/miner-ui-4.md

@@ -0,0 +1,116 @@
+# Igneum Miner UI 4: Overview, Cards, Ember on the row
+
+6 October 2026, evening. the project lead: "add Cards under its own tab, and have Overview and the cool mining demo on the main
+page with the revamped C option", then "incorporate Ember into the Cards tab beautifully", then "I would like the new
+miner UI to go into .15". Branch `miner-ui-4` from the 0.3.15 tip `6ea9497` (untouched), worktree
+`../igneum-wt-miner-ui-4`. Rust: one route (`GET /live-dag.js`, `server.rs`), nothing else.
+
+## 1. The rail
+
+Overview, Cards, Earnings, Prove, Settings; Logs and Quit in the foot; a bottom tab bar under 720 px.
+
+## 2. Overview
+
+| Block | What |
+|---|---|
+| The hero (the project lead's pick, C) | the fleet rate at 84 px on a graphite-to-obsidian fade, W with MH/W, £ a day at the user's price, blocks (this run, lifetime) beside it; Start/Stop as the full-width bar under it with its state sentence at the right |
+| The chain, live | the site's `live-dag.js` (a byte copy at `app/igneum-app/ui/live-dag.js`, served by the engine at `/live-dag.js`), mounted on the engine's own `api/live` with `mine: 'you'` so this machine's lane reads "you" and its blocks take a molten ring; the legend words in HTML under the canvas: yours, pending, included, excluded, proven, locked; Pause; a tooltip per block. The engine's `/api/live` is OWED (it maps the local node's RPC into the site's reply shape: `{ok, state, blocks[{hash, ts, blue_score, daa, parents, chain, color, miner, locked, final, shards, proven}], finality.checkpoints}`); until it exists the module reports `failed` and the app's own 10-minute blocks strip draws in its place with the note "The full chain view needs the next engine update". |
+| The node line | as 0.3.15, Details under it |
+| Activity | the event feed in the app's voice (the strip canvas moved into the chain card as the fallback) |
+
+## 3. Cards
+
+| Block | What |
+|---|---|
+| The Tuning strip | the goal control (Efficiency, Balanced, Maximum) with "about £X a day at Y W"; the fleet saving ("Ember saves 84 W, £0.56 a day over 1 tuned card", `View.fleetSaving`); Tune all; the schedule line; Power control only when an NVIDIA card has it off |
+| The rows | as 0.3.15 (state word with its reason, MH/s, W with MH/W, £ a day, °C, the switch, the chevron) with Ember as the second layer |
+| The flame mark | the brand mark's two polygons, 16 px, outline when not tuned, filling bottom-up with step k of n while tuning (molten), solid ember when tuned, half grey when measured only |
+| The Ember line | "Tuned 2 h ago · 2470 MHz at 80% · next check Sunday · saves 84 W, 0.16% of rate"; "Tuning: step 4 of 9 · about 7 min left" with the bar; "Measured, not tuned · Power control is off"; "Not tuned yet · starts after 2 min of steady mining"; the fleet pause and a stop in the same place |
+| The W cell | before → after when tuned (`tune_before_watts` → the live draw) |
+| The MH/W cell | a 44 px sparkline of the ladder's MH/W per step, the chosen step as a dot |
+| Tune / Retune / Stop | the row's button; Retune once tuned |
+| The chevron | the cap slider, the applied or Retry line, memory and clocks, the card's own goal (As the fleet, Efficiency, Balanced, Maximum: `POST api/tune/goal {key, goal}`, "" clears; a build without it gets a toast), Retune, the Tuned line, the curve (W across, MH/s up, every step a dot, the chosen ringed, a rejected one hollow), identities, the facts |
+
+Fields read (Ember Tune 5429e82, on the 0.3.16 lane): `tune_before_watts`, `tune_before_mhs` (step 0 of the last full
+plan; 0 = never; the UI falls back to `tune_curve[0]` only for a full plan on an older build and claims no saving for a
+confirm or baseline plan), `sweep_watts`, `sweep_mhs`, `sweep_eff`, `tune_curve`, `tune_goal`, `tune_step`,
+`tune_steps`, `tune_eta_s`, `sweep_state`, `sweep_note`, `tune_floor` (asked for). `View.ember` and `View.beforeOf`
+carry the rules; `view.test.mjs` covers every state.
+
+## 4. Screenshots (the mock on port 4318 with the rig state, the 5090 tuned, the 4070 at step 4 of 9)
+
+`docs/plans/miner-ui-4/u01-overview-dark-1440.png`, `u02-overview-light-1440.png`, `u03-cards-dark-1440.png` (the
+5090's details open: cap, goal, Retune, the curve), `u04-cards-light-1440.png`, `u05-overview-dark-390.png`,
+`u06-cards-dark-390.png`, `u07-overview-light-390.png`, `u08-cards-light-390.png`, `u09-overview-mac-dark.png`.
+The chain scene in the shots is the mock's `/api/live` (four lanes, one block a second, "you" ringed); on a real
+0.3.15 engine the fallback strip shows until `/api/live` lands.
+
+## 5. Owed
+
+| What | Who |
+|---|---|
+| `GET /api/live` on the engine: the local node's blocks over the window, mapped into the site's shape, this machine's vote keys as the lane "you" | engine |
+| `card.tune_floor` | Ember (said yes) |
+| `watts_total`, `pounds_per_day` for the tray tip; `address.balance_wei`; `price_gbp_per_ign` | engine (from miner-ui-3) |
+| Re-copy `site/live-dag.js` over `app/igneum-app/ui/live-dag.js` when the site agent's audit commit lands, so the two stay identical | the shipper at merge |
+
+Tests: `node --test app/igneum-app/ui/*.test.mjs`: 37 pass.
+
+## 6. The second tip (20:0x UK): /api/live on the engine, the copy sweep, the project lead's goal rulings
+
+| What | Where |
+|---|---|
+| `GET /api/live` on the engine: the observer's `/api/live` (the URL `ota.rs` already polls for the identity count) through curl, cached 2 s per window, this machine's blocks marked as the lane "you" by matching the block's miner id (the first 8 hex of its vote key hash) against every card's `ids`; `state.you_blocks` and `state.source: "observer"` added; `{ok:false, error}` when the observer is unreachable or the build has no observer address, which the UI meets with its own blocks strip. Four unit tests on the shaping from a fixture in the observer's shape (`live::tests`). The local node speaks gRPC and wRPC only and the engine carries no client for either (no TLS, no websocket stack), so a local-node source is OWED (a JSON endpoint on igneumd, or a wRPC client here); the reply shape stays the same when it comes. | `src/live.rs`, `src/server.rs`, `src/main.rs`, `ota::live_api_from` made `pub` |
+| The copy sweep: 150 strings, every one listed in `docs/plans/miner-ui-4-copy.md` | `ui/index.html`, `ui/app.js`, the tests |
+| the project lead's rulings: the per-card inherit option is "Default · Balanced" (grey, following the shared goal); "Default" wherever a per-card setting follows the shared one (the cap's "Back to Default"); the Cards strip is titled "Ember Tune"; every goal option carries its meaning as a tooltip (Efficiency "most hashes per watt, a little rate traded", Balanced "a little rate for most of the saving", Maximum "most hashes, watts second", Default "the goal set for all cards") | `ui/index.html`, `ui/app.js` |
+
+The Rust tests did not run on this Mac (its cargo predates the lock file's version 4); the box runs them at the
+merge, as the rule says. UI tests: 37 pass. Screenshots `u01`, `u03`, `u04`, `u06` reshot after the sweep.
+
+## 7. Pinned to the next engine (ember-tune fd03f35, then b55bc1f), 20:5x UK
+
+Numbering (the shipper, 21:3x UK): 0.3.16 is tonight's corrective cut, the same release as 0.3.15 (this branch's ui/
+at 872f1c9) under a new number; the engine fields and the pinning below ship as 0.3.17 with miner-ui-4's tip e31acab.
+
+| Field | Where the UI reads it |
+|---|---|
+| `mining.watts_total`, `mining.pounds_per_day` | the Overview hero and Earnings use the engine's figures when present (`View.fleetWatts`, `View.fleetPounds`), else the UI's own sums as before |
+| `address.balance_wei` (string or null), `address.balance_age_s` (-1 until read), `address.balance_note`, `address.price_gbp_per_ign` (null until a signed manifest carries a price) | Earnings' first row: "12.3456 IGN · in the wallet · read 20 s ago" (`View.balanceWords`); a priced balance shows £ with "at the signed price"; an older engine without the field keeps the row as it was |
+| `card.tune_floor` | the Ember line's "(the lowest clock Ember will set)" |
+| `/api/live` reply `source` ("node" when igneumd answers `igneum_getRecentBlocks`, "site" until then; `pending: true` before the first body) | the chain scene's note (`View.liveNote`): "From your node. Your blocks are ringed." or "From Igneum’s observer. Your blocks are ringed."; "you" is matched in the UI from every card's vote-key ids whatever the source names the lane |
+
+At the 0.3.17 merge `src/live.rs` is ember-tune's (the fuller one, node first, site second); this branch's 0.3.15
+file is superseded and its `source` word is "site" too, so nothing in the UI changes between the two.
+
+## 8. N4 (the frozen tip), the capture route, and PC 2's light render (6 October 2026, 23:0x to 23:4x UK)
+
+| What | Where |
+|---|---|
+| N4, the app half: `sync_decision_v2` (the old rule AND the watch line's `tip_age_s` at or under 120 s AND peers >= 1; the cause word frozen / no peers / syncing / behind on `node.sync_cause`; the state word "behind" or "no peers", never "synced" on a frozen tip); `is_stall_exit` (code 45 or a "STALLED '" tail line; the first restarts the miner, the second since the node started restarts the node and re-dials its peers); `node.tip_age_s`, `node.stall_exits`. The known-failed case is the first test. UI: "Node behind · 1 peer · 133,000 blocks · last block 53 min ago" with the cause line, the pill "Node behind", the big button's "waiting: the node is behind the chain". The node lane's miner half is ca3-v4-0316. | `src/engine.rs`, `src/state.rs`, `ui/app.js`, `view.test.mjs` |
+| (b) a screenshot from the machine itself: `POST /api/shot {name}` writes `SHOT <path>` on the host protocol (beside URL, STATE, EXIT); the Mac host answers with `WKWebView.takeSnapshot`, the Windows host with WebView2 `CapturePreview` (PNG), to `<data root>/shots/igneum-<name>-<unix>.png` (`live::shot_path`, the name reduced to [a-z0-9-]); `relay/playbooks/app-shot.ps1` asks and waits, a collect job's glob `shots/*.png` brings the file back. Read-only. The Swift parses (`swiftc -parse`); the C++ builds on the GitHub runner at the cut (`BUILD-APP.bat` already links shlwapi.lib). | `src/server.rs`, `src/live.rs`, `app/mac/IgneumMiner.swift`, `app/windows/host.cpp`, `relay/playbooks/app-shot.ps1` |
+| The light-theme showcase capture: Edge headless on PC 2 wrote nothing in three takes (154.0.4258.53, exit 0, no stderr, in the app's elevated session); PC 2's `api/state` and `api/live` were fetched by `relay/playbooks/app-state-grab.ps1` into the data root and collected, and the ui-mock replayed them (`IGNEUM_MOCK_STATE`, `IGNEUM_MOCK_LIVE`) through the real 0.3.16 UI on the Mac: `docs/plans/miner-ui-4/pc2-0.3.16/pc2-overview-light-1440.png`, `pc2-cards-light-1440.png`, `pc2-overview-dark-1440.png`, captioned "rendered from PC 2's live state at 23:33 UK" (DESKTOP-KMCV30N, RTX 5090 at 103 MH/s and 317 W, node synced, 5 peers). Handed to the site lane. | `tools/ui-mock/server.mjs`, `relay/playbooks/app-state-grab.ps1` |
+| The fleet watts count mining and tuning cards only (PC 2's idle integrated card drew 48 W and was summed); the Ember off-state line no longer promises a start. | `ui/app.js` |
+
+Tests: UI 39; the app crate on the box 152 passed (the N4 pair, the shot path, the four live tests among them).
+
+## 9. The rebased fold (7 October 2026, 23:20 UK; renumbered: tonight's 0.3.17 is a node-only hotfix on the 0.3.16 app tree, and this branch at afc331bd ships as 0.3.18 on release-0.3.18)
+
+- Rebased onto a9eb58f1 (origin/release-0.3.15). ui/ comes wholly from this branch; Ember's finality-paused hunk (ember-tune 1357d280) is folded in as `View.finalityWords(f)`: while finality is paused the node sub-line and the lock row say "paused" and nothing calls a lock final. Test in view.test.mjs (41 UI tests).
+- src/extnode.rs reads the node lane's `igneum_getNodeInfo` shape: `params` (every resolved consensus field, compared value by value against the manifest's keys), `network` (must be equal), `powEngine` ("stub" = refused on the port check, and a fault on the app's own node: node state `stub`, pill "Node fault", one error event). 168 box tests.
+- src/live.rs is Ember's merged module at the merge (nothing of this branch's lives there any more).
+- External node re-decided (the Mac, 7 October 2026 00:18 UK: the hand node left and the app sat on "node stopped" all night). While the app reads another node, or refused one, it checks the port every 5 s; gone for 60 s (`extnode::TAKEOVER_WAIT_S`) it starts its own node on the freed ports and says so in Activity; a node back inside the wait is kept. api/state node.mode own | external | none with node.mode_reason, shown under the Node details. Test `an_external_node_that_goes_away_hands_the_ports_to_the_app_after_the_wait` (169 box tests).
+
+## 10. The merge check (7 October 2026, 03:20 UK; 74c12665, on the 0.3.18 list after afc331bd)
+
+- Design note from the node lane's 30-s propagation reading: a node behind a slow link keeps mining its own chain and the N4 "synced" test cannot see it. New `src/merge.rs` (pure): `not_merging(MergeCheck)` is true when every sink the network reports is more than the merge depth ahead of ours (the node's `params.merge_depth` via igneum_getNodeInfo, else 3,600) and none of our blocks has appeared in the network's view for 120 s, after at least 120 s of mining. Known-failed test first (`a_node_whose_blocks_never_merge_reads_behind_and_holds_the_miner`).
+- Engine: every 30 s while mining, the observer's /api/live (600-s window, this machine's lanes marked) gives the network's sink and the newest block of ours it shows (`merge::view_of`); the watch line's decision runs after sync_decision_v2; the state reads "behind" with sync_cause "not merging" and the message "behind: your blocks are not merging into the network"; the miner is held through the existing synced gate; one error event with the gap in blocks. Source owed: peers' own sinks (igneum_getNodeInfo over the peer list) when the node exposes them; the observer is the first view.
+- UI: nodeWords' behind case names the cause. 42 UI tests, 172 box tests. Nothing of this on the Mac tonight.
+- Decided (main, 7 October 2026, 05:00 UK): `igneum_getPeers` stays on 0.3.19; the observer-based merge check ships in 0.3.18. The Mac check when it takes 0.3.18: the hands moved to the build box at 00:18 UK, so hand node 1 no longer holds 26610; the app, left in external mode, reads "node stopped" and starts its own node only on relaunch (the apply). Check after the apply: own node on 26610/26611, api/state node.mode own, digest_source rpc, synced; the miner stays paused. Read-only; nothing else that night.
+- Node side landed: 6e4ace3f on build/ca3-v4-0318 (04:53 UK) adds `blockrate: { bps, ghostdagK, mergeDepth, finalityDepth, pruningDepth }` to igneum_getNodeInfo (devnet: bps 1, ghostdagK 18, mergeDepth 3600). The app reads blockrate.mergeDepth (b7d33e8e) and keeps the 3,600 fallback, since whether 6e4ace3f rides in 0.3.18 is the shipper's call. `igneum_getPeers` (lastDeliveredBlueScore) stays on 0.3.19.
+
+## 11. Workers after an OTA relaunch (7 October 2026, 05:20 UK; 0.3.18)
+
+- Known-failed case: PC 1 at the 0.3.17 relaunch (04:51:43Z, docs/plans/release-0.3.17.md PC 1 row): the app started its workers while the node was still syncing; the card watchdog clocked the silence anyway (a miner with no template prints no status), restarted each once, then faulted every card "no status line from the miner for 90 s (restarted once already)", pid 0, 0.0 MH/s on; faulted cards were never restarted, including at the synced transition.
+- Fix (src/watchdog.rs, src/engine.rs): a miner is judged only while the node is synced (the start, no-status and zero-rate clocks hold at now while it is not); a worker silent from its start with the node synced is one restart then a fault at 60 s (`START_S`), 90 s stays for a running one; a fault the node's readiness explains (`faulted_by_node`) is released by `Event::NodeSynced` when the node syncs, the card starts again with an Activity line; one Activity line per card at its first worker start. Test `a_worker_started_while_the_node_syncs_is_not_faulted_and_a_faulted_one_returns_at_sync` (recorded state), 173 box tests.
+- The pre-apply card set already persists (cards' enabled flags live in settings and the relaunch planned every enabled card); the fault, not the plan, was the failure.
+- Read-back changed the reading (relaunch-engine-and-workers.txt, 05:40 UK): PC 1's node reported synced=true from the first second; the miners started at +14, +25 and +38 s, subscribed, then every template fetch timed out at 5 s for 180 s while the node ran its finality catch-up (checkpoints 8053 to 8055 locking), so no status line was printed; the watchdog restarted each at 90 s and faulted each at 180 s. Rule added: "template fetch timed out" is the miner's heartbeat (`Event::TemplateTimeout`): the silence clocks start over from the line, the card reads "waiting for the node to answer block templates", one Activity line per episode, and the miner is judged again from its last line (60 s of nothing at all after it is still a restart). The synced-gate half stays. Test extended with the recorded sequence; 173 box tests. The node-side half (the template RPC blocking under the finality replay after a restart) is with the node lane.

docs/plans/miner-ui-5-first-share-runbook.md

@@ -0,0 +1,67 @@
+# Runbook: "first share within 10 minutes of download in 9 of 10 fresh Windows installs"
+
+7 October 2026, miner-ui-5. The measurement behind the `/evidence` line in mission item 6 (docs/analysis/mission/mission.md
+2.6, reinvent.md 3.1). Written for the shipper (ae892a8b0f78fe31c) to run at the Devnet 2 gate of each cut; the app
+lane does not run it. Nothing here touches PC 1 or a live manifest.
+
+## What is measured
+
+Ten fresh Windows 11 installs, each timed from the download's first byte to the first accepted share or block, with
+three timed steps between: the installer (download start to the app's first screen), the node (first screen to
+`node.synced` true), the card (synced to the first `ACCEPTED block` line, or the first share once pool-0 exists). The
+claim passes when 9 of 10 reach the first accepted block or share inside 600 s of the download's start.
+
+## Where the numbers come from
+
+| Step | Start mark | End mark | Read from |
+|---|---|---|---|
+| Download | the first byte of `Igneum-Miner-Setup-<v>.exe` (the fetch's own timestamp) | the file complete | the job script's clock |
+| Install and first screen | the file complete | `api/state` answers with `phase` = welcome (the engine is up) | the app's URL file, then `api/state` |
+| Setup | welcome | `setup_done` true (Continue, Make me an address, I have saved my key, Start mining: the playbook clicks or the job posts `api/setup`) | `api/state` |
+| Node | `setup_done` | `node.synced` true and `node.state` synced | `api/state` |
+| Card | synced | `ladder.first_block_at` set (the first `ACCEPTED block` line) or, with pool-0, the first `share_result` line | `api/state.ladder` |
+| Total | download start | `ladder.first_block_at` (or the share) | both clocks, the box's and the VM's, read as UTC |
+
+`api/state.ladder.first_synced_at` and `first_mining_at` carry the node and card marks from the engine's own clock; the
+runbook takes those over the script's reads when both exist.
+
+## The ten installs
+
+- Ten fresh Windows 11 VMs (or ten fresh user profiles on the two PCs is NOT acceptable: a fresh profile shares the
+  machine's node data and its driver state). The fleet's Windows wave boxes are the candidates; PC 1 and PC 2 are not
+  (PC 1 is the project lead's desk, PC 2 holds a standing node).
+- Each VM: the GPU driver installed, no Igneum folder under `%LOCALAPPDATA%`, the clock right (the clock card blocks
+  mining otherwise and the run is void, not a fail).
+- The download is the public installer URL of the cut under test, through the dl host, never a scratch copy.
+- The run is `node tools/build-job.mjs run --target <vm> --script relay/playbooks/first-share.ps1` with the playbook
+  recording the six marks as `RESULT` lines; the collect job brings `app/ladder.json` back.
+
+## The playbook's RESULT lines
+
+```
+RESULT step=download start=<utc ms> end=<utc ms> bytes=<n>
+RESULT step=install end=<utc ms>
+RESULT step=setup end=<utc ms>
+RESULT step=node end=<utc ms> synced_at=<ladder.first_synced_at>
+RESULT step=card end=<utc ms> mining_at=<ladder.first_mining_at> first_block_at=<ladder.first_block_at> hash=<ladder.first_block_hash>
+RESULT total_s=<end - download start> pass=<true|false>
+```
+
+A run without a `first_block_at` inside 1,800 s ends with `pass=false` and the step it stalled in. A Poisson miss is
+a fail too: an 8 GB card at 100 GH/s has a 46 percent chance inside the first hour (reinvent 1.4), so the claim is
+about the install and the node, and the card step is measured against the Poisson expectation from
+`api/ladder.network.hashrate_hps` and the card's rate (`mining.hash_total`); a run whose card step passed the
+expected gap by less than one gap is reported as "within expectation" beside the pass word.
+
+## What is published
+
+`/evidence` gets one table: ten rows (card model, driver, the four step times, the total, pass), the median of each
+step, the pass count, the cut's version and the installer's sha256. The site lane owns the page; the shipper hands
+it the table as a JSON file (`site/evidence/first-share-<version>.json`) with the same keys as the RESULT lines.
+
+## Known holes
+
+- Pool-0 is not built into the app yet (reinvent 3.5), so today the end mark is the first accepted block, not a share;
+  the claim's words say "first share or block" until the pool field ships.
+- SmartScreen (reinvent 3.1) adds two clicks the playbook must make; the time they take counts in the install step.
+- A VM without a GPU passthrough measures the node steps only and is reported as such, not as a pass.

docs/plans/miner-ui-5.md

@@ -0,0 +1,98 @@
+# Igneum Miner UI 5: the ladder shown everywhere, the miner's first month
+
+7 October 2026, 10:1x to 11:xx UK. Mission item 6 (docs/analysis/mission/mission.md 2.6; the brief is
+docs/analysis/mission/reinvent.md 1, 2, 3.2 to 3.7 and 7). Branch `miner-ui-5` from the miner-ui-4 tip 5d9c55a2
+(release-0.3.18, since renumbered 0.3.19), worktree `../igneum-wt-miner-ui-5`. Nothing published; the shipper cuts it.
+The site lane (a4b202cabca2d95c0) owns `/live` and `/miners`; the node lane (a283f5f0d364ceef0) owns the RPC fields
+listed in section 6.
+
+## 1. What is built
+
+| Part | Where | What |
+|---|---|---|
+| (a) The Poisson count-up | Overview, `#first-wait`; `View.poisson` | from the first job until the first block of this install: "A card like yours finds a block about every 1.6 hours on today's network. Chance so far: 31%." The gap is `/api/stats hashrate` over the fleet rate (`mining.hash_total`) at one block a second; the chance is `1 - e^(-elapsed / gap)` from the moment mining started this run. Over an 8-hour gap the pool line sits under it. The ring fills with the chance. Hover names the two fields and the formula. |
+| (b) The block card | Overview, `#block-card`; `View.blockCard`; `src/ladder.rs` | raised by the engine on the first block of the install, every 100th, 1,000th and 10,000th, and the first block of a new card (`ladder.milestone`); in place, never a dialog; stays until dismissed (the key is stored, so a relaunch does not re-raise it). "Block 1,284,117 is yours." (the DAA score the node logged), the card and its rate and share, "4.88 IGN to 0xdd44…86E8 (72 producer points, 8 for signing, ramp 19%)", "rank 41 of 1,204 keys · day 23 of 30", the hash, Open in the explorer (`/block/<hash>`), Save the card, Copy the link. The hash joins the miner's `ACCEPTED block nonce=` line to the node's `PoW accepted <hash> … nonce` line by nonce (the node logs every block it validates). |
+| Save the card | `drawCard` in app.js, `POST /api/card`, `src/card.rs`, `platform::reveal_file` | a 1200x630 PNG drawn on a canvas from the card's own words with the fonts the app ships (no network call): the mark, "Block N is yours", the card and rate, the IGN line, rank and day, the miner key and hash, the explorer URL. The miner's object, never the project's number: no network rate, no block count. The engine writes it under `<data root>/cards/` and reveals it in Finder or Explorer. `u00-block-card-1200x630.png` is the one the mock drew. |
+| (c) Earnings in IGN first | Earnings, the money card; `View.earningsLines` | line 1 "7,680 IGN a day at your last hour's rate (4 blocks, 80.00 IGN each) · about 6,912 IGN expected at 100 MH/s" (measured first, the expectation beside it; the expectation alone before the first block); line 2 "2,592 blocks in 30 days, 207,360 IGN" from `getFinalityWeights keys[].blocks` at today's reward, with the shards; line 3 the balance (unchanged); line 4 the typed price: a £ per IGN the user types, kept in the page's storage, never fetched, "about £384 a day at £0.05 per IGN, your figure · no exchange lists IGN"; line 5 "your cards are 0.100% of the network · weight rank 41 of 1,204 keys · 23 of 30 days"; line 6 electricity unchanged plus "2,133 IGN per kWh"; the dev fee unchanged. Every number's `title` names its field. |
+| The per-card line | Cards rows | an "IGN a day" cell per card from its rate, the network rate and the reward (hover: the fields) |
+| (d) The ladder | Earnings `#ladder-card` (the rungs with their lines and hovers), Overview `#ladder-strip` (the seven chips and the current rung's line); `View.ladderRungs` | rungs: first block; your key has a vote; your signature is in checkpoint K; full window; rank by weight; signing streak; your card proved a shard. Every threshold is read from the node's `params` (`dust`, `weightWindow`, `presenceWindow`), never a constant: the devnet reads "5 blocks to a vote" and "2 of 2 hours", mainnet "100 blocks" and "30 of 30 days". The words, in copy law: "Your key has a vote." "Your signature is in checkpoint 184,220." "30 of 30 days. Full weight." "Rank 41 of 1,204 keys." "Signing 8 of 80 points, 41 days unbroken." "Your card proved shard 3 of block 1,284,117." |
+| The chain facts | `GET /api/ladder`, `src/chainfacts.rs` | the node's `igneum_getFinalityWeights` on the EVM port first (OWED on the node, section 6), else the observer's `/api/live finality.weights` (the same reply relayed, keys cut to 64, ids as 8 hex) plus `/api/stats`; this machine's keys ranked by `blocks`; cached 10 s; the reply names its source and the dashboard says it ("through the observer" until the node answers). |
+| The machine's record | `src/ladder.rs`, `<app dir>/ladder.json`, `api/state.ladder` | first block (time, card, hash, DAA), blocks per UTC day (the days-mined ring), the checkpoints signed and which locked (`VOTE index=` and `LOCK checkpoint` lines), the signing streak (a gap over the presence window ends it), the paid shards (`src/prover.rs`), the milestone, the first-hour marks (node synced, card mining). |
+| (e) The public profile opt-in | Settings "Make my page public"; `settings.profile_public`, `api/settings {profile_public}` | off by default; the words say what becomes public (key ids, blocks, rank, presence, card model). The site reads the switch through the app's existing report path (owed to the site lane; today the switch is stored and shown, nothing leaves the machine). |
+| (f) The first-hour timeline | Earnings "Your first hour"; `View.timeline` | Installed (`settings.installed_at`), App started, Node synced (`ladder.first_synced_at`), Card mining (`ladder.first_mining_at`), First block, First payout (the coinbase of the first block), each as "+N min" from the install. |
+| Prove | `#shard-card` | "Your card proved shard 3 of block 1,284,117." with the IGN, on the newest paid record |
+| Activity | `EVENT_MAP` | "Your first block, found by RTX 4070", "Block 1,000 of this machine, found by …", "First block on …" |
+
+## 2. The chain scene (EMBER 02, taken from the site lane)
+
+the project lead's renderer pack (11:3x UK): `ui/live-dag.js` (sha256 82d56565…, IgneumDag 2.0.2, master 9162c847: the phone-width options narrow/narrowWindow 30/narrowLanes 4/narrowMinNode 11, hairlines off when narrow, percent-only checkpoint labels; the app passes fps 60 on both mounts and narrow when the window is under 720 px on the compact card, since compact never auto-narrows; 2.0.1 e78f2d38… added the site lane's real-data options, maxLanes 7 with the own key first and an OTHERS lane, minNode 9.5, merge hairlines within two lanes, provenGlow; 2.0.0 was 582f2e73…) and `ui/proof-core.js` (c2a094a6…,
+IgneumProof 2.0.0) are byte-identical copies of the site-ui-4 files; the engine serves `proof-core.js` beside
+`live-dag.js`. The Overview card mounts the compact mode (`compact: true, window: 60, poll: false`); Inspect, or a
+click on a block, opens the full scene under it with the block inspector in the site's words (Proof in progress /
+Proof complete / Checkpoint locked / Block observed; Proof shards, Inclusion, Miner key, Blue score, DAA score,
+Parent links, Header time, Checkpoint, Finality; the note on separate states), the filter tabs (All blocks, Selected
+chain, Your blocks), the window stepper, Follow and Pause. One owner of the feed: the page reads the engine's
+`api/live?window=120` every 2 s and pushes the reply into both scenes; `mine` matches every vote key id of this
+machine's cards (the 8 hex the feed names as `b.miner`), never the payout address. `--included` and `--excluded` are on
+`:root` for both themes. The fallback strip (this machine's own blocks) draws after three failed reads. The legend
+reads "Your blocks" as in the reference.
+
+Caption fact from the site lane: the observer's per-block shard states read "planned" for every chain block in the window while its paid counters move (10:08 UK), so the live scene shows no proven block until the observer's read is fixed (the fleet lane has it); the mock's feed shows the proven state.
+
+## 3. Gate results
+
+| Gate | Result |
+|---|---|
+| A Devnet 2 key walks every rung on screen in a view test | `view.test.mjs` "a Devnet 2 key walks every rung on screen": key 6ad0e117 under the finality params the devnet node reports (`api/live params`, 7 Oct 2026: dust 5, weightWindow 7,200, presenceWindow 20; Devnet 2's override file sets none of them, so it runs the same values) goes nothing → first block → vote → signature in checkpoint 8,496 → 2 of 2 hours → rank 3 of 4 → 15 min unbroken → shard 3 of block 1,284,117; every rung's `field` matches `getFinalityWeights|getFinalityCheckpoints|igneum_getProofRecords|/api/stats|this app`. The mainnet-sized walk (100 blocks, 30 days, the observer's cap of 64) is the next test. |
+| Every number names its RPC field on hover | `View.FIELDS` (23 sentences) in every `title`; the rungs, the Earnings lines, the block card lines, the Cards cell, the count-up |
+| The PNG opens; no network call is made to make it | `u00-block-card-1200x630.png` drawn by the mock page through Playwright's chromium; the page's only calls while drawing are `document.fonts.load` of the app's own woff2 files |
+| "First share within 10 minutes of download in 9 of 10 fresh Windows installs" | written as a runbook for the shipper, not run: `docs/plans/miner-ui-5-first-share-runbook.md` |
+| Tests | UI 47 (42 before; the five new ones); the app crate on the box 190 + 27 + 8 (ladder 10, chainfacts 4, card 3 among them) |
+
+## 4. Captures (`docs/plans/miner-ui-5-shots/`, the ui-mock's scenarios firstwait, firstblock, ladder)
+
+`u00-block-card-1200x630.png` the saved card; `u01-overview-firstwait-dark-1440` the count-up and the strip; `u02`/`u03`
+the first block's card, dark and light; `u04`/`u14` the full scene with a block in the inspector, dark and light;
+`u05`/`u06` Earnings with the ladder and the timeline open; `u07` the shard card; `u08` the Cards row with IGN a day;
+`u09` Settings with the profile switch; `u10` to `u13` the Overview and Earnings at 390, both themes. Captured through
+Playwright's own chromium (never Google Chrome.app) against `tools/ui-mock/server.mjs 4319`.
+
+## 5. Owed by this lane, and what the site lane and the Discord lane take
+
+| What | Who |
+|---|---|
+| The Cards setup screen's "about N blocks a day" from the priors file (reinvent 3.2, Cards rows) | this lane, once the priors ship in the signed manifest (the file lives on the site today) |
+| The QR of the explorer link on the saved card (reinvent 3.3) | this lane; the URL is printed in full instead |
+| The opt-in reaching the site (the address page's noindex lifted for a key whose app switched it on) | the site lane and this lane together: the switch rides the app's existing report upload as `profile_public` |
+| `/live` weight leaderboard and `/miners` census with the same words | the site lane; the field list and the rung words were sent to it (section 7) |
+| `#first-blocks` posts and the Voter and Window roles | the Discord lane; the shapes are in `docs/community/discord/ladder.md`, nothing posted |
+| Sound on a block | not built (verdict table: watch) |
+
+## 6. RPC fields the node does not expose yet (sent to the node lane)
+
+| Field | Why the app needs it | What the app does meanwhile |
+|---|---|---|
+| `igneum_getFinalityWeights` on the EVM JSON-RPC port (the wRPC `getFinalityWeights` reply as is) | the engine carries no wRPC client; today the facts come through the observer's relay, which cuts the table to 64 keys and so cannot rank a key below 64 | reads `/api/live finality.weights` and says "through the observer" on hover; "Below the top 64 keys" when the key is not listed |
+| `igneum_getFinalityCheckpoints` the same way | the locked index and the certificate list from this machine's node | `/api/stats finality.latest_locked_index` |
+| `getFinalityCheckpoints checkpoints[].signers` (the key hashes in the certificate bitmap), or a per-key `lastSignedLockedIndex` | "Your signature is in checkpoint K" as a chain fact | the app's own `VOTE index=` lines, read as locked once a `LOCK checkpoint` line reaches them; the hover says so |
+| `getFinalityWeights keys[].daysMined` (distinct days with a blue block in the window) and `keys[].firstBlockDaa` | "30 of 30 days" as a chain fact; the Window role; the `/live` days-mined column | the app's own day ring (`ladder.json`), which only counts what this install saw |
+| `getFinalityWeights keys[].streakDays` or `keys[].lastMissedDaa` | the signing streak as a chain fact | the app's own unbroken-vote reading; `participation` is shown beside it |
+| `getFinalityWeights keys[].rank` or a `getFinalityKey {keyHash}` reply with blocks, voter, participation, rank, daysMined, streak | one call per machine instead of the whole table | the table sorted on the client |
+| `igneum_getProofRecords` by key (the paid shards of a key over a range) | "your card proved shard N of block M" for records this install did not watch | `src/prover.rs` reports what it submitted and saw paid |
+
+## 7. Sent to the site lane (so `/live` and `/miners` match the app word for word)
+
+The rung names and lines of section 1 (d); the fields: `getFinalityWeights params.dust / weightWindow / presenceWindow`,
+`keys[].blocks / voter / participation / strippedUntilDaa / pubkey`, `totalWeight`, `activeWeight`, `voters`,
+`checkpointIndex`; `getFinalityCheckpoints latestLockedIndex / nextIndex / finalityActive`; `/api/stats hashrate`,
+`block_reward.miner_ign`, `block_reward.ramp_factor`; the leaderboard column order (rank, key id, blocks in window,
+days mined, presence, last block) with "weight, never hashrate: a card that arrived today sits at the bottom".
+
+## 8. Copy added (the copy law: no em dashes, no two-beat antithesis, no aphorisms; every line names a number or an action)
+
+"Waiting for your first block." "A card like yours finds a block about every 1.6 hours on today's network. Chance so
+far: 31%." "Above an 8-hour gap a pool pays by the share, every minute. The pool setting arrives with pool-0." "Block
+1,284,117 is yours." "Open in the explorer" "Save the card" "Copy the link" "Your key has a vote." "61 of 100 blocks to
+a vote." "Your signature is in checkpoint 184,220." "30 of 30 days. Full weight." "Rank 41 of 1,204 keys." "Below the
+top 64 keys." "Signing 8 of 80 points, 41 days unbroken." "Your card proved shard 3 of block 1,284,117." "Proving is
+off." "Type a price" "Use it" "Make my page public" "Your first hour" "The ladder".